@mks2508/coolify-mks-cli-mcp 0.5.0 → 0.6.1

package/src/tools/handlers.ts

@@ -1,771 +1,579 @@
 /**
  * MCP Tool handlers for Coolify.
  *
- * Handles execution of all 21 Coolify MCP tools.
+ * All handlers route through the Coolify SDK facade.
+ * Uses a generic mcpCall wrapper to eliminate boilerplate.
  *
  * @module
  */
 
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'
-import { isOk, isErr } from '@mks2508/no-throw'
-import type { CoolifyService } from '../coolify/index.js'
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { Coolify } from "../sdk.js";
+
+/** Singleton SDK for MCP usage (reads env vars / config file). */
+let _sdk: Coolify | null = null;
+function getSdk(): Coolify {
+  if (!_sdk) _sdk = Coolify.fromEnv();
+  return _sdk;
+}
 
 /**
- * Handler function for tool calls.
+ * Wraps an SDK call into an MCP tool result.
+ * On success → JSON response. On error → isError response.
+ *
+ * @param fn - Async function that calls the SDK (throws on error)
+ * @param label - Error context label
+ * @returns MCP CallToolResult
+ */
+async function mcpCall(
+  fn: (sdk: Coolify) => Promise<unknown>,
+  label: string,
+): Promise<CallToolResult> {
+  try {
+    const data = await fn(getSdk());
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            typeof data === "object" && data !== null
+              ? { success: true, ...data }
+              : { success: true, result: data },
+            null,
+            2,
+          ),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `${label}: ${error instanceof Error ? error.message : String(error)}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+}
+
+/** Wraps SDK call returning an array into { count, items } format. */
+async function mcpList(
+  fn: (sdk: Coolify) => Promise<unknown[]>,
+  itemKey: string,
+  label: string,
+): Promise<CallToolResult> {
+  return mcpCall(async (sdk) => {
+    const items = await fn(sdk);
+    return { count: items.length, [itemKey]: items };
+  }, label);
+}
+
+/**
+ * Main handler — routes tool calls to SDK methods.
  *
  * @param name - Tool name
  * @param args - Tool arguments
- * @param coolify - CoolifyService instance
- * @returns Tool call result
+ * @returns MCP tool result
  */
 export async function handleToolCall(
   name: string,
   args: Record<string, unknown>,
-  coolify: CoolifyService
 ): Promise<CallToolResult> {
-  const initResult = await coolify.init()
-  if (isErr(initResult)) {
-    return {
-      content: [{ type: 'text', text: `Coolify not configured: ${initResult.error.message}` }],
-      isError: true
-    }
-  }
+  const a = args as any;
 
   switch (name) {
-    case 'deploy':
-      return handleDeploy(coolify, args as unknown as DeployArgs)
-    case 'get_env_vars':
-      return handleGetEnvVars(coolify, args as unknown as GetEnvVarsArgs)
-    case 'set_env_vars':
-      return handleSetEnvVars(coolify, args as unknown as SetEnvVarsArgs)
-    case 'get_deployment_status':
-      return handleGetDeploymentStatus(coolify, args as unknown as GetDeploymentStatusArgs)
-    case 'list_applications':
-      return handleListApplications(coolify, args as unknown as ListApplicationsArgs)
-    case 'delete_application':
-      return handleDeleteApplication(coolify, args as unknown as DeleteApplicationArgs)
-    case 'get_application_logs':
-      return handleGetApplicationLogs(coolify, args as unknown as GetApplicationLogsArgs)
-    case 'start_application':
-      return handleStartApplication(coolify, args as unknown as StartApplicationArgs)
-    case 'stop_application':
-      return handleStopApplication(coolify, args as unknown as StopApplicationArgs)
-    case 'restart_application':
-      return handleRestartApplication(coolify, args as unknown as RestartApplicationArgs)
-    case 'get_deployment_history':
-      return handleGetDeploymentHistory(coolify, args as unknown as GetDeploymentHistoryArgs)
-    case 'update_application':
-      return handleUpdateApplication(coolify, args as unknown as UpdateApplicationArgs)
-    case 'set_domains':
-      return handleSetDomains(coolify, args as unknown as SetDomainsArgs)
-    case 'list_servers':
-      return handleListServers(coolify)
-    case 'get_server':
-      return handleGetServer(coolify, args as unknown as GetServerArgs)
-    case 'list_projects':
-      return handleListProjects(coolify)
-    case 'list_teams':
-      return handleListTeams(coolify)
-    case 'get_server_destinations':
-      return handleGetServerDestinations(coolify, args as unknown as GetServerDestinationsArgs)
-    case 'create_application':
-      return handleCreateApplication(coolify, args as unknown as CreateApplicationArgs)
-    case 'create_project':
-      return handleCreateProject(coolify, args as unknown as CreateProjectArgs)
-    case 'get_resource_usage':
-      return handleGetResourceUsage(coolify, args as unknown as GetResourceUsageArgs)
-    case 'health_check':
-      return handleHealthCheck(coolify)
-    case 'get_application_details':
-      return handleGetApplicationDetails(coolify, args as unknown as GetApplicationDetailsArgs)
-    case 'list_deployments':
-      return handleListDeployments(coolify)
-    case 'get_deployment':
-      return handleGetDeployment(coolify, args as unknown as GetDeploymentArgs)
-    case 'get_application_deployments':
-      return handleGetApplicationDeployments(coolify, args as unknown as GetApplicationDeploymentsArgs)
-    default:
-      return {
-        content: [{ type: 'text', text: `Unknown tool: ${name}` }],
-        isError: true
-      }
-  }
-}
-
-// Tool argument types
-interface DeployArgs {
-  uuid: string
-  force?: boolean
-  tag?: string
-}
-
-interface GetEnvVarsArgs {
-  uuid: string
-}
-
-interface SetEnvVarsArgs {
-  uuid: string
-  envVars: Record<string, string>
-}
-
-interface GetDeploymentStatusArgs {
-  uuid: string
-}
-
-interface ListApplicationsArgs {
-  teamId?: string
-  projectId?: string
-}
-
-interface DeleteApplicationArgs {
-  uuid: string
-}
-
-interface GetApplicationLogsArgs {
-  uuid: string
-  tail?: number
-}
-
-interface StartApplicationArgs {
-  uuid: string
-}
-
-interface StopApplicationArgs {
-  uuid: string
-}
-
-interface RestartApplicationArgs {
-  uuid: string
-}
-
-interface GetDeploymentHistoryArgs {
-  uuid: string
-}
-
-interface UpdateApplicationArgs {
-  uuid: string
-  name?: string
-  description?: string
-  buildPack?: 'dockerfile' | 'nixpacks' | 'static' | 'dockercompose'
-  gitBranch?: string
-  portsExposes?: string
-  installCommand?: string
-  buildCommand?: string
-  startCommand?: string
-  domains?: string
-  isForceHttpsEnabled?: boolean
-  isAutoDeployEnabled?: boolean
-}
-
-interface SetDomainsArgs {
-  uuid: string
-  domains: string
-  forceHttps?: boolean
-}
-
-interface GetServerArgs {
-  serverUuid: string
-}
-
-interface GetServerDestinationsArgs {
-  serverUuid: string
-}
-
-interface CreateApplicationArgs {
-  name: string
-  serverUuid: string
-  projectUuid: string
-  environmentUuid: string
-  githubRepoUrl: string
-  description?: string
-  branch?: string
-  buildPack?: 'dockerfile' | 'nixpacks' | 'static' | 'dockercompose'
-  type?: string
-  dockerComposeLocation?: string
-  dockerfileLocation?: string
-  baseDirectory?: string
-}
-
-interface CreateProjectArgs {
-  name: string
-  description?: string
-}
-
-interface GetResourceUsageArgs {
-  uuid: string
-}
-
-interface GetApplicationDetailsArgs {
-  uuid: string
-}
-
-interface GetDeploymentArgs {
-  deploymentUuid: string
-}
-
-interface GetApplicationDeploymentsArgs {
-  uuid: string
-  skip?: number
-  take?: number
-}
-
-// Handler implementations
-async function handleDeploy(coolify: CoolifyService, args: DeployArgs): Promise<CallToolResult> {
-  const result = await coolify.deploy({
-    uuid: args.uuid,
-    force: args.force ?? false,
-    tag: args.tag
-  })
+    // ─── Applications ──────────────────────────────────────────────────
+    case "deploy":
+      return mcpCall(
+        (s) =>
+          s.applications
+            .deploy(a.uuid, { force: a.force, tag: a.tag })
+            .then((r) => ({
+              deploymentUuid: r.deploymentUuid,
+              resourceUuid: r.resourceUuid,
+              message: "Deployment started",
+            })),
+        "Deployment failed",
+      );
+    case "list_applications":
+      return mcpList(
+        (s) => s.applications.list(),
+        "applications",
+        "Failed to list applications",
+      );
+    case "get_application_details":
+      return mcpCall(
+        (s) =>
+          s.applications.resolve(a.uuid).then((app) => ({ application: app })),
+        "Failed to get application",
+      );
+    case "start_application":
+      return mcpCall(
+        (s) =>
+          s.applications
+            .start(a.uuid, { force: a.force, instantDeploy: a.instantDeploy })
+            .then(() => ({
+              message: `Application ${a.uuid} started`,
+            })),
+        "Failed to start application",
+      );
+    case "stop_application":
+      return mcpCall(
+        (s) =>
+          s.applications.stop(a.uuid).then(() => ({
+            message: `Application ${a.uuid} stopped`,
+          })),
+        "Failed to stop application",
+      );
+    case "restart_application":
+      return mcpCall(
+        (s) =>
+          s.applications.restart(a.uuid).then(() => ({
+            message: `Application ${a.uuid} restarted`,
+          })),
+        "Failed to restart application",
+      );
+    case "delete_application":
+      return mcpCall(
+        (s) =>
+          s.applications.delete(a.uuid).then(() => ({
+            message: `Application ${a.uuid} deleted`,
+          })),
+        "Failed to delete application",
+      );
+    case "update_application":
+      return mcpCall(
+        (s) =>
+          s.applications
+            .update(a.uuid, {
+              name: a.name,
+              description: a.description,
+              buildPack: a.buildPack,
+              gitBranch: a.gitBranch,
+              portsExposes: a.portsExposes,
+              installCommand: a.installCommand,
+              buildCommand: a.buildCommand,
+              startCommand: a.startCommand,
+              domains: a.domains,
+              isForceHttpsEnabled: a.isForceHttpsEnabled,
+              isAutoDeployEnabled: a.isAutoDeployEnabled,
+            })
+            .then((app) => ({
+              message: `Application ${a.uuid} updated`,
+              application: app,
+            })),
+        "Failed to update application",
+      );
+    case "get_application_logs":
+      return mcpCall(
+        (s) =>
+          s.applications
+            .logs(a.uuid, { tail: a.tail, serviceName: a.serviceName })
+            .then((logs) => ({
+              timestamp: logs.timestamp,
+              logCount: logs.logs.length,
+              logs: logs.logs,
+            })),
+        "Failed to get logs",
+      );
+    case "get_deployment_history":
+      return mcpList(
+        (s) => s.applications.deployments(a.uuid),
+        "deployments",
+        "Failed to get deployment history",
+      );
+    case "get_application_deployments":
+      return mcpList(
+        (s) => s.applications.deployments(a.uuid),
+        "deployments",
+        "Failed to get deployments",
+      );
+    case "execute_command":
+      return mcpCall(
+        (s) => s.applications.exec(a.uuid, a.command),
+        "Failed to execute command",
+      );
+
+    // ─── Environment Variables ─────────────────────────────────────────
+    case "get_env_vars":
+      return mcpCall(
+        (s) =>
+          s.applications.envVars(a.uuid).then((vars) => ({
+            total: vars.length,
+            runtime: vars.filter((v) => v.is_runtime),
+            buildtime: vars.filter((v) => v.is_buildtime),
+          })),
+        "Failed to get env vars",
+      );
+    case "set_env_vars":
+      return mcpCall((s) => {
+        const entries = Object.entries(a.envVars as Record<string, string>);
+        return s.applications
+          .bulkSetEnv(
+            a.uuid,
+            entries.map(([key, value]) => ({ key, value })),
+          )
+          .then(() => ({
+            message: `Set ${entries.length} environment variable(s)`,
+          }));
+      }, "Failed to set env vars");
+    case "bulk_update_env_vars":
+      return mcpCall(
+        (s) =>
+          s.applications.bulkSetEnv(a.uuid, a.envVars).then(() => ({
+            message: `Bulk updated ${a.envVars.length} variable(s)`,
+          })),
+        "Failed to bulk update env vars",
+      );
+
+    // ─── Domains ───────────────────────────────────────────────────────
+    case "set_domains":
+      return mcpCall(
+        (s) =>
+          s.applications
+            .update(a.uuid, {
+              domains: a.domains,
+              isForceHttpsEnabled: a.forceHttps ?? true,
+            })
+            .then(() => ({
+              message: `Domains set for ${a.uuid}`,
+              domains: a.domains.split(",").map((d: string) => d.trim()),
+            })),
+        "Failed to set domains",
+      );
+
+    // ─── Deployment Status ─────────────────────────────────────────────
+    case "get_deployment_status":
+      return mcpCall(
+        (s) =>
+          s.applications
+            .resolve(a.uuid)
+            .then((app) => ({ status: app.status })),
+        "Failed to get status",
+      );
+
+    // ─── Deployments ───────────────────────────────────────────────────
+    case "list_deployments":
+      return mcpList(
+        (s) => s.deployments.active(),
+        "deployments",
+        "Failed to list deployments",
+      );
+    case "get_deployment":
+      return mcpCall(
+        (s) =>
+          s.deployments.get(a.deploymentUuid).then((d) => ({ deployment: d })),
+        "Failed to get deployment",
+      );
+    case "cancel_deployment":
+      return mcpCall(
+        (s) =>
+          s.deployments
+            .cancel(a.deploymentUuid)
+            .then(() => ({ message: "Deployment cancelled" })),
+        "Failed to cancel deployment",
+      );
+
+    // ─── Servers ───────────────────────────────────────────────────────
+    case "list_servers":
+      return mcpList(
+        (s) => s.servers.list(),
+        "servers",
+        "Failed to list servers",
+      );
+    case "get_server":
+      return mcpCall(
+        (s) => s.servers.get(a.serverUuid).then((srv) => ({ server: srv })),
+        "Failed to get server",
+      );
+    case "get_server_destinations":
+      return mcpList(
+        (s) => s.servers.destinations(a.serverUuid),
+        "destinations",
+        "Failed to get destinations",
+      );
+    case "get_server_resources":
+      return mcpList(
+        (s) => s.servers.resources(a.serverUuid),
+        "resources",
+        "Failed to get server resources",
+      );
+    case "get_server_domains":
+      return mcpList(
+        (s) => s.servers.domains(a.serverUuid),
+        "domains",
+        "Failed to get server domains",
+      );
+    case "validate_server":
+      return mcpCall(
+        (s) =>
+          s.servers
+            .validate(a.serverUuid)
+            .then(() => ({ message: "Server validated" })),
+        "Failed to validate server",
+      );
+
+    // ─── Projects ──────────────────────────────────────────────────────
+    case "list_projects":
+      return mcpList(
+        (s) => s.projects.list(),
+        "projects",
+        "Failed to list projects",
+      );
+    case "create_project":
+      return mcpCall(
+        (s) =>
+          s.projects.create(a.name, a.description).then((p) => ({
+            message: `Project "${a.name}" created`,
+            uuid: p.uuid,
+          })),
+        "Failed to create project",
+      );
+    case "create_application":
+      return mcpCall(
+        (s) =>
+          s.applications
+            .create({
+              name: a.name,
+              description: a.description,
+              projectUuid: a.projectUuid,
+              environmentUuid: a.environmentUuid,
+              serverUuid: a.serverUuid,
+              type: a.type || "public",
+              githubAppUuid: a.githubAppUuid,
+              githubRepoUrl: a.githubRepoUrl,
+              branch: a.branch,
+              buildPack: a.buildPack,
+              portsExposes: a.portsExposes,
+              dockerComposeLocation: a.dockerComposeLocation,
+              dockerfileLocation: a.dockerfileLocation,
+              baseDirectory: a.baseDirectory,
+            })
+            .then((r) => ({
+              message: `Application "${a.name}" created`,
+              uuid: r.uuid,
+            })),
+        "Failed to create application",
+      );
+
+    // ─── Teams ─────────────────────────────────────────────────────────
+    case "list_teams":
+      return mcpList((s) => s.teams.list(), "teams", "Failed to list teams");
+    case "get_current_team":
+      return mcpCall(
+        (s) => s.teams.current().then((t) => ({ team: t })),
+        "Failed to get current team",
+      );
+    case "get_team_members":
+      return mcpList(
+        (s) => s.teams.members(a.teamId),
+        "members",
+        "Failed to get team members",
+      );
+
+    // ─── Databases ─────────────────────────────────────────────────────
+    case "list_databases":
+      return mcpList(
+        (s) => s.databases.list(),
+        "databases",
+        "Failed to list databases",
+      );
+    case "get_database":
+      return mcpCall(
+        (s) => s.databases.get(a.uuid).then((db) => ({ database: db })),
+        "Failed to get database",
+      );
+    case "create_database":
+      return mcpCall(
+        (s) =>
+          s.databases.create(a.dbType, a.data).then((r) => ({
+            message: `${a.dbType} database created`,
+            uuid: r.uuid,
+          })),
+        "Failed to create database",
+      );
+    case "delete_database":
+      return mcpCall(
+        (s) =>
+          s.databases
+            .delete(a.uuid)
+            .then(() => ({ message: "Database deleted" })),
+        "Failed to delete database",
+      );
+    case "start_database":
+      return mcpCall(
+        (s) =>
+          s.databases
+            .start(a.uuid)
+            .then(() => ({ message: "Database started" })),
+        "Failed to start database",
+      );
+    case "stop_database":
+      return mcpCall(
+        (s) =>
+          s.databases
+            .stop(a.uuid)
+            .then(() => ({ message: "Database stopped" })),
+        "Failed to stop database",
+      );
+    case "restart_database":
+      return mcpCall(
+        (s) =>
+          s.databases
+            .restart(a.uuid)
+            .then(() => ({ message: "Database restarted" })),
+        "Failed to restart database",
+      );
+
+    // ─── Services ──────────────────────────────────────────────────────
+    case "list_services":
+      return mcpList(
+        (s) => s.services.list(),
+        "services",
+        "Failed to list services",
+      );
+    case "get_service":
+      return mcpCall(
+        (s) => s.services.get(a.uuid).then((svc) => ({ service: svc })),
+        "Failed to get service",
+      );
+    case "start_service":
+      return mcpCall(
+        (s) =>
+          s.services.start(a.uuid).then(() => ({ message: "Service started" })),
+        "Failed to start service",
+      );
+    case "stop_service":
+      return mcpCall(
+        (s) =>
+          s.services.stop(a.uuid).then(() => ({ message: "Service stopped" })),
+        "Failed to stop service",
+      );
+    case "restart_service":
+      return mcpCall(
+        (s) =>
+          s.services
+            .restart(a.uuid)
+            .then(() => ({ message: "Service restarted" })),
+        "Failed to restart service",
+      );
+    case "delete_service":
+      return mcpCall(
+        (s) =>
+          s.services
+            .delete(a.uuid)
+            .then(() => ({ message: "Service deleted" })),
+        "Failed to delete service",
+      );
+
+    // ─── Private Keys ──────────────────────────────────────────────────
+    case "list_private_keys":
+      return mcpList(
+        (s) => s.keys.list(),
+        "keys",
+        "Failed to list private keys",
+      );
+    case "get_private_key":
+      return mcpCall(
+        (s) => s.keys.get(a.uuid).then((k) => ({ privateKey: k })),
+        "Failed to get private key",
+      );
+
+    // ─── Smart Resolution ──────────────────────────────────────────────
+    case "resolve_application":
+      return mcpCall(
+        (s) =>
+          s.applications.resolve(a.query).then((app) => ({
+            application: {
+              uuid: app.uuid,
+              name: app.name,
+              status: app.status,
+              fqdn: app.fqdn,
+            },
+          })),
+        "Failed to resolve application",
+      );
+    case "resolve_server":
+      return mcpCall(
+        (s) =>
+          s.servers.resolve(a.query).then((srv) => ({
+            server: {
+              uuid: srv.uuid,
+              name: srv.name,
+              ip: srv.ip,
+              is_reachable: srv.is_reachable,
+            },
+          })),
+        "Failed to resolve server",
+      );
+
+    // ─── Diagnostics ───────────────────────────────────────────────────
+    case "diagnose_application":
+      return mcpCall((s) => s.diagnose.app(a.query), "Diagnosis failed");
+    case "diagnose_server":
+      return mcpCall((s) => s.diagnose.server(a.query), "Diagnosis failed");
+    case "find_infrastructure_issues":
+      return mcpCall(
+        (s) => s.diagnose.infrastructure(),
+        "Infrastructure scan failed",
+      );
+
+    // ─── Batch Operations ──────────────────────────────────────────────
+    case "restart_project_apps":
+      return mcpCall(
+        (s) => s.batch.restartProject(a.projectUuid),
+        "Batch restart failed",
+      );
+    case "redeploy_project_apps":
+      return mcpCall(
+        (s) => s.batch.redeployProject(a.projectUuid, a.force),
+        "Batch redeploy failed",
+      );
+    case "stop_all_apps":
+      return mcpCall((s) => s.batch.stopAll(), "Stop all failed");
+
+    // ─── Network Diagnostics ─────────────────────────────────────────
+    case "inspect_network":
+      return mcpCall(
+        (s) => s.network.inspect(a.uuid, a.servicesToTest),
+        "Network inspection failed",
+      );
+    case "analyze_deploy_failure":
+      return mcpCall(
+        (s) => s.diagnose.deployFailure(a.deploymentUuid),
+        "Deploy analysis failed",
+      );
+
+    // ─── Version / Health ──────────────────────────────────────────────
+    case "get_version":
+      return mcpCall(
+        (s) => s.version().then((v) => ({ version: v.version })),
+        "Failed to get version",
+      );
+    case "health_check":
+      return mcpCall(
+        (s) =>
+          s.servers.list().then(() => ({
+            status: "healthy",
+            message: "Coolify API is accessible",
+          })),
+        "Health check failed",
+      );
+    case "get_resource_usage":
+      return mcpCall(
+        (s) =>
+          s.applications
+            .resolve(a.uuid)
+            .then((app) => ({ status: app.status })),
+        "Failed to get resource usage",
+      );
 
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          success: true,
-          deploymentUuid: result.value.deploymentUuid,
-          resourceUuid: result.value.resourceUuid,
-          message: 'Deployment started'
-        }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Deployment failed: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleGetEnvVars(coolify: CoolifyService, args: GetEnvVarsArgs): Promise<CallToolResult> {
-  const result = await coolify.getEnvironmentVariables(args.uuid)
-
-  if (isOk(result)) {
-    const runtimeVars = result.value.filter(ev => ev.is_runtime)
-    const buildtimeVars = result.value.filter(ev => ev.is_buildtime)
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          success: true,
-          total: result.value.length,
-          runtimeCount: runtimeVars.length,
-          buildtimeCount: buildtimeVars.length,
-          runtime: runtimeVars,
-          buildtime: buildtimeVars
-        }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to get env vars: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleSetEnvVars(coolify: CoolifyService, args: SetEnvVarsArgs): Promise<CallToolResult> {
-  const result = await coolify.setEnvironmentVariables(args.uuid, args.envVars)
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: `Set ${Object.keys(args.envVars).length} environment variable(s). Use deploy tool to apply changes.`
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to set env vars: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleGetDeploymentStatus(coolify: CoolifyService, args: GetDeploymentStatusArgs): Promise<CallToolResult> {
-  const result = await coolify.getApplicationStatus(args.uuid)
-
-  if (isOk(result)) {
-    return {
-      content: [{ type: 'text', text: JSON.stringify({ status: result.value }, null, 2) }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to get status: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleListApplications(coolify: CoolifyService, args: ListApplicationsArgs): Promise<CallToolResult> {
-  const result = await coolify.listApplications(args.teamId, args.projectId)
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({ success: true, count: result.value.length, applications: result.value }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to list applications: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleDeleteApplication(coolify: CoolifyService, args: DeleteApplicationArgs): Promise<CallToolResult> {
-  const result = await coolify.deleteApplication(args.uuid)
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({ success: true, message: `Application ${args.uuid} deleted successfully` }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to delete application: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleGetApplicationLogs(coolify: CoolifyService, args: GetApplicationLogsArgs): Promise<CallToolResult> {
-  const result = await coolify.getApplicationLogs(args.uuid, { tail: args.tail })
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          success: true,
-          timestamp: result.value.timestamp,
-          logCount: result.value.logs.length,
-          logs: result.value.logs
-        }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to get logs: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleStartApplication(coolify: CoolifyService, args: StartApplicationArgs): Promise<CallToolResult> {
-  const result = await coolify.startApplication(args.uuid)
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({ success: true, message: `Application ${args.uuid} started`, application: result.value }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to start application: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleStopApplication(coolify: CoolifyService, args: StopApplicationArgs): Promise<CallToolResult> {
-  const result = await coolify.stopApplication(args.uuid)
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({ success: true, message: `Application ${args.uuid} stopped`, application: result.value }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to stop application: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleRestartApplication(coolify: CoolifyService, args: RestartApplicationArgs): Promise<CallToolResult> {
-  const result = await coolify.restartApplication(args.uuid)
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({ success: true, message: `Application ${args.uuid} restarted`, application: result.value }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to restart application: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleGetDeploymentHistory(coolify: CoolifyService, args: GetDeploymentHistoryArgs): Promise<CallToolResult> {
-  const result = await coolify.getApplicationDeploymentHistory(args.uuid)
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({ success: true, count: result.value.length, deployments: result.value }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to get deployment history: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleUpdateApplication(coolify: CoolifyService, args: UpdateApplicationArgs): Promise<CallToolResult> {
-  const result = await coolify.updateApplication(args.uuid, {
-    name: args.name,
-    description: args.description,
-    buildPack: args.buildPack,
-    gitBranch: args.gitBranch,
-    portsExposes: args.portsExposes,
-    installCommand: args.installCommand,
-    buildCommand: args.buildCommand,
-    startCommand: args.startCommand,
-    domains: args.domains,
-    isForceHttpsEnabled: args.isForceHttpsEnabled,
-    isAutoDeployEnabled: args.isAutoDeployEnabled
-  })
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          success: true,
-          message: `Application ${args.uuid} updated. Use deploy tool to apply changes.`,
-          application: result.value
-        }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to update application: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleSetDomains(coolify: CoolifyService, args: SetDomainsArgs): Promise<CallToolResult> {
-  const result = await coolify.updateApplication(args.uuid, {
-    domains: args.domains,
-    isForceHttpsEnabled: args.forceHttps ?? true
-  })
-
-  if (isOk(result)) {
-    const domainList = args.domains.split(',').map(d => d.trim())
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          success: true,
-          message: `Domains configured for application ${args.uuid}`,
-          domains: domainList,
-          forceHttps: args.forceHttps ?? true,
-          nextSteps: [
-            'Ensure DNS records point to your server IP',
-            'Use deploy tool to apply domain changes',
-            'SSL certificates will be auto-generated via Let\'s Encrypt'
-          ]
-        }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to set domains: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleListServers(coolify: CoolifyService): Promise<CallToolResult> {
-  const result = await coolify.listServers()
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({ success: true, count: result.value.length, servers: result.value }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to list servers: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleGetServer(coolify: CoolifyService, args: GetServerArgs): Promise<CallToolResult> {
-  const result = await coolify.getServer(args.serverUuid)
-
-  if (isOk(result)) {
-    return {
-      content: [{ type: 'text', text: JSON.stringify({ success: true, server: result.value }, null, 2) }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to get server: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleListProjects(coolify: CoolifyService): Promise<CallToolResult> {
-  const result = await coolify.listProjects()
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({ success: true, count: result.value.length, projects: result.value }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to list projects: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleListTeams(coolify: CoolifyService): Promise<CallToolResult> {
-  const result = await coolify.listTeams()
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({ success: true, count: result.value.length, teams: result.value }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to list teams: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleGetServerDestinations(coolify: CoolifyService, args: GetServerDestinationsArgs): Promise<CallToolResult> {
-  const result = await coolify.getServerDestinations(args.serverUuid)
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          success: true,
-          serverUuid: args.serverUuid,
-          count: result.value.length,
-          destinations: result.value
-        }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to get destinations: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleCreateApplication(coolify: CoolifyService, args: CreateApplicationArgs): Promise<CallToolResult> {
-  const result = await coolify.createApplication({
-    name: args.name,
-    description: args.description,
-    projectUuid: args.projectUuid,
-    environmentUuid: args.environmentUuid,
-    serverUuid: args.serverUuid,
-    type: (args.type as any) || 'public',
-    githubRepoUrl: args.githubRepoUrl,
-    branch: args.branch,
-    buildPack: args.buildPack,
-    dockerComposeLocation: args.dockerComposeLocation,
-    dockerfileLocation: args.dockerfileLocation,
-    baseDirectory: args.baseDirectory,
-  })
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          success: true,
-          message: `Application "${args.name}" created successfully`,
-          uuid: result.value.uuid,
-          nextSteps: [
-            'Use set_env_vars to configure environment variables',
-            'Use deploy to start the first deployment'
-          ]
-        }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to create application: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleCreateProject(coolify: CoolifyService, args: CreateProjectArgs): Promise<CallToolResult> {
-  const result = await coolify.createProject(args.name, args.description)
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          success: true,
-          message: `Project "${args.name}" created successfully`,
-          uuid: result.value.uuid,
-        }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to create project: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleGetResourceUsage(coolify: CoolifyService, args: GetResourceUsageArgs): Promise<CallToolResult> {
-  // For now, use getApplicationStatus - Coolify API doesn't have a separate resource usage endpoint
-  const result = await coolify.getApplicationStatus(args.uuid)
-
-  if (isOk(result)) {
-    return {
-      content: [{ type: 'text', text: JSON.stringify({ success: true, status: result.value }, null, 2) }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to get resource usage: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleHealthCheck(coolify: CoolifyService): Promise<CallToolResult> {
-  // Try to list servers as a health check
-  const result = await coolify.listServers()
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({ success: true, status: 'healthy', message: 'Coolify API is accessible' }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Health check failed: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleGetApplicationDetails(coolify: CoolifyService, args: GetApplicationDetailsArgs): Promise<CallToolResult> {
-  // List all applications and filter by UUID to get full details
-  const result = await coolify.listApplications()
-
-  if (isOk(result)) {
-    const app = result.value.find((a) => a.uuid === args.uuid)
-    if (app) {
+    default:
       return {
-        content: [{ type: 'text', text: JSON.stringify({ success: true, application: app }, null, 2) }]
-      }
-    }
-    return {
-      content: [{ type: 'text', text: `Application ${args.uuid} not found` }],
-      isError: true
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to get application details: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleListDeployments(coolify: CoolifyService): Promise<CallToolResult> {
-  const result = await coolify.listDeployments()
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          success: true,
-          count: result.value.length,
-          deployments: result.value
-        }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to list deployments: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleGetDeployment(coolify: CoolifyService, args: GetDeploymentArgs): Promise<CallToolResult> {
-  const result = await coolify.getDeployment(args.deploymentUuid)
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          success: true,
-          deployment: result.value
-        }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to get deployment: ${result.error.message}` }],
-    isError: true
-  }
-}
-
-async function handleGetApplicationDeployments(coolify: CoolifyService, args: GetApplicationDeploymentsArgs): Promise<CallToolResult> {
-  const result = await coolify.getApplicationDeployments(args.uuid, args.skip, args.take)
-
-  if (isOk(result)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          success: true,
-          count: result.value.length,
-          deployments: result.value
-        }, null, 2)
-      }]
-    }
-  }
-
-  return {
-    content: [{ type: 'text', text: `Failed to get application deployments: ${result.error.message}` }],
-    isError: true
+        content: [{ type: "text", text: `Unknown tool: ${name}` }],
+        isError: true,
+      };
   }
 }