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

package/src/sdk.ts

@@ -0,0 +1,597 @@
+/**
+ * Coolify SDK — Fluent, resource-based API for Coolify.
+ *
+ * Every parameter from CoolifyService is exposed. Nothing is lost.
+ *
+ * @module
+ */
+
+import { isErr, type Result } from "@mks2508/no-throw";
+import { CoolifyService } from "./coolify/index.js";
+import type {
+  ICoolifyAppOptions,
+  ICoolifyApplication,
+  ICoolifyDatabase,
+  ICoolifyDatabaseBackup,
+  ICoolifyDeleteResult,
+  ICoolifyDeployment,
+  ICoolifyDeployResult,
+  ICoolifyDestination,
+  ICoolifyEnvironment,
+  ICoolifyLogs,
+  ICoolifyLogsOptions,
+  ICoolifyPrivateKey,
+  ICoolifyProject,
+  ICoolifyServer,
+  ICoolifyServerDomain,
+  ICoolifyServerResource,
+  ICoolifyService as ICoolifyServiceType,
+  ICoolifyTeam,
+  ICoolifyUpdateOptions,
+  ICoolifyVersion,
+  IProgressCallback,
+} from "./coolify/types.js";
+import type { ICoolifyEnvVar } from "./coolify/index.js";
+
+/** SDK configuration options. */
+export interface ICoolifyOptions {
+  /** Coolify instance URL (e.g., https://coolify.example.com) */
+  url: string;
+  /** API token (generate in Coolify > Settings > API Tokens) */
+  token: string;
+}
+
+/** Cascade delete options. */
+export interface IDeleteOptions {
+  deleteConfigurations?: boolean;
+  deleteVolumes?: boolean;
+  dockerCleanup?: boolean;
+  deleteConnectedNetworks?: boolean;
+}
+
+/** Pagination options. */
+export interface IPaginationOptions {
+  page?: number;
+  perPage?: number;
+}
+
+function unwrap<T>(result: Result<T, Error>): T {
+  if (isErr(result)) throw result.error;
+  return result.value;
+}
+
+// ─── Resource Classes ────────────────────────────────────────────────────────
+
+class ApplicationsResource {
+  constructor(private svc: CoolifyService) {}
+
+  /** List all applications. Supports filtering and pagination. */
+  async list(
+    options?: { teamId?: string; projectId?: string } & IPaginationOptions,
+  ): Promise<ICoolifyApplication[]> {
+    return unwrap(
+      await this.svc.listApplications(
+        options?.teamId,
+        options?.projectId,
+        options?.page,
+        options?.perPage,
+      ),
+    );
+  }
+
+  async listSummaries() {
+    return unwrap(await this.svc.listApplicationSummaries());
+  }
+
+  /** Resolve application by name, domain, or UUID. */
+  async resolve(query: string): Promise<ICoolifyApplication> {
+    return unwrap(await this.svc.resolveApplication(query));
+  }
+
+  /** Create a new application. All ICoolifyAppOptions supported. */
+  async create(options: ICoolifyAppOptions, onProgress?: IProgressCallback) {
+    return unwrap(await this.svc.createApplication(options, onProgress));
+  }
+
+  /** Deploy an application. Supports force rebuild and progress tracking. */
+  async deploy(
+    uuid: string,
+    options?: { force?: boolean; tag?: string },
+    onProgress?: IProgressCallback,
+  ): Promise<ICoolifyDeployResult> {
+    return unwrap(await this.svc.deploy({ uuid, ...options }, onProgress));
+  }
+
+  /** Start application. Supports force and instant_deploy. */
+  async start(
+    uuid: string,
+    options?: { force?: boolean; instantDeploy?: boolean },
+  ): Promise<ICoolifyApplication> {
+    return unwrap(await this.svc.startApplication(uuid, options));
+  }
+
+  async stop(uuid: string): Promise<ICoolifyApplication> {
+    return unwrap(await this.svc.stopApplication(uuid));
+  }
+
+  async restart(uuid: string): Promise<ICoolifyApplication> {
+    return unwrap(await this.svc.restartApplication(uuid));
+  }
+
+  /** Delete application with optional cascade options. */
+  async delete(
+    uuid: string,
+    options?: IDeleteOptions,
+  ): Promise<ICoolifyDeleteResult> {
+    return unwrap(await this.svc.deleteApplication(uuid, options));
+  }
+
+  /** Update application configuration. All ICoolifyUpdateOptions supported. */
+  async update(
+    uuid: string,
+    options: ICoolifyUpdateOptions,
+  ): Promise<ICoolifyApplication> {
+    return unwrap(await this.svc.updateApplication(uuid, options));
+  }
+
+  /** Get application logs. Supports lines, serviceName, follow. */
+  async logs(
+    uuid: string,
+    options?: ICoolifyLogsOptions,
+  ): Promise<ICoolifyLogs> {
+    return unwrap(await this.svc.getApplicationLogs(uuid, options));
+  }
+
+  /** Get deployment history with optional pagination. */
+  async deployments(
+    uuid: string,
+    skip?: number,
+    take?: number,
+  ): Promise<ICoolifyDeployment[]> {
+    return unwrap(await this.svc.getApplicationDeployments(uuid, skip, take));
+  }
+
+  async exec(uuid: string, command: string) {
+    return unwrap(await this.svc.executeCommand(uuid, command));
+  }
+
+  async envVars(uuid: string): Promise<ICoolifyEnvVar[]> {
+    return unwrap(await this.svc.getEnvironmentVariables(uuid));
+  }
+
+  async setEnv(
+    uuid: string,
+    key: string,
+    value: string,
+    isBuildTime?: boolean,
+  ) {
+    return unwrap(
+      await this.svc.setEnvironmentVariable(uuid, key, value, isBuildTime),
+    );
+  }
+
+  async bulkSetEnv(
+    uuid: string,
+    vars: Array<{ key: string; value: string; is_preview?: boolean }>,
+  ) {
+    return unwrap(await this.svc.bulkUpdateEnvironmentVariables(uuid, vars));
+  }
+
+  async deleteEnv(uuid: string, key: string) {
+    return unwrap(await this.svc.deleteEnvironmentVariable(uuid, key));
+  }
+}
+
+class DatabasesResource {
+  constructor(private svc: CoolifyService) {}
+
+  async list(options?: IPaginationOptions): Promise<ICoolifyDatabase[]> {
+    return unwrap(
+      await this.svc.listDatabases(options?.page, options?.perPage),
+    );
+  }
+
+  async listSummaries() {
+    return unwrap(await this.svc.listDatabaseSummaries());
+  }
+
+  async get(uuid: string): Promise<ICoolifyDatabase> {
+    return unwrap(await this.svc.getDatabase(uuid));
+  }
+
+  async create(type: string, data: Record<string, unknown>) {
+    return unwrap(await this.svc.createDatabase(type, data));
+  }
+
+  async update(uuid: string, data: Record<string, unknown>) {
+    return unwrap(await this.svc.updateDatabase(uuid, data));
+  }
+
+  async start(uuid: string) {
+    return unwrap(await this.svc.startDatabase(uuid));
+  }
+  async stop(uuid: string) {
+    return unwrap(await this.svc.stopDatabase(uuid));
+  }
+  async restart(uuid: string) {
+    return unwrap(await this.svc.restartDatabase(uuid));
+  }
+
+  /** Delete with optional cascade options. */
+  async delete(uuid: string, options?: IDeleteOptions) {
+    return unwrap(await this.svc.deleteDatabase(uuid, options));
+  }
+
+  async backups(uuid: string): Promise<ICoolifyDatabaseBackup[]> {
+    return unwrap(await this.svc.listDatabaseBackups(uuid));
+  }
+
+  async getBackup(dbUuid: string, backupUuid: string) {
+    return unwrap(await this.svc.getDatabaseBackup(dbUuid, backupUuid));
+  }
+
+  async createBackup(dbUuid: string, data: Record<string, unknown>) {
+    return unwrap(await this.svc.createDatabaseBackup(dbUuid, data));
+  }
+
+  async deleteBackup(dbUuid: string, backupUuid: string) {
+    return unwrap(await this.svc.deleteDatabaseBackup(dbUuid, backupUuid));
+  }
+}
+
+class ServicesResource {
+  constructor(private svc: CoolifyService) {}
+
+  async list(options?: IPaginationOptions): Promise<ICoolifyServiceType[]> {
+    return unwrap(await this.svc.listServices(options?.page, options?.perPage));
+  }
+
+  async listSummaries() {
+    return unwrap(await this.svc.listServiceSummaries());
+  }
+
+  async get(uuid: string): Promise<ICoolifyServiceType> {
+    return unwrap(await this.svc.getService(uuid));
+  }
+
+  async create(data: Record<string, unknown>) {
+    return unwrap(await this.svc.createService(data));
+  }
+
+  async update(uuid: string, data: Record<string, unknown>) {
+    return unwrap(await this.svc.updateService(uuid, data));
+  }
+
+  async start(uuid: string) {
+    return unwrap(await this.svc.startService(uuid));
+  }
+  async stop(uuid: string) {
+    return unwrap(await this.svc.stopService(uuid));
+  }
+  async restart(uuid: string) {
+    return unwrap(await this.svc.restartService(uuid));
+  }
+
+  /** Delete with optional cascade options. */
+  async delete(uuid: string, options?: IDeleteOptions) {
+    return unwrap(await this.svc.deleteService(uuid, options));
+  }
+
+  async envVars(uuid: string): Promise<ICoolifyEnvVar[]> {
+    return unwrap(await this.svc.listServiceEnvVars(uuid));
+  }
+
+  async setEnv(
+    uuid: string,
+    data: { key: string; value: string; is_preview?: boolean },
+  ) {
+    return unwrap(await this.svc.createServiceEnvVar(uuid, data));
+  }
+}
+
+class ServersResource {
+  constructor(private svc: CoolifyService) {}
+
+  async list(options?: IPaginationOptions): Promise<ICoolifyServer[]> {
+    return unwrap(await this.svc.listServers(options?.page, options?.perPage));
+  }
+
+  async listSummaries() {
+    return unwrap(await this.svc.listServerSummaries());
+  }
+
+  async resolve(query: string): Promise<ICoolifyServer> {
+    return unwrap(await this.svc.resolveServer(query));
+  }
+
+  async get(uuid: string): Promise<ICoolifyServer> {
+    return unwrap(await this.svc.getServer(uuid));
+  }
+
+  async create(data: Record<string, unknown>) {
+    return unwrap(await this.svc.createServer(data));
+  }
+
+  async delete(uuid: string) {
+    return unwrap(await this.svc.deleteServer(uuid));
+  }
+
+  async resources(uuid: string): Promise<ICoolifyServerResource[]> {
+    return unwrap(await this.svc.getServerResources(uuid));
+  }
+
+  async domains(uuid: string): Promise<ICoolifyServerDomain[]> {
+    return unwrap(await this.svc.getServerDomains(uuid));
+  }
+
+  async destinations(uuid: string): Promise<ICoolifyDestination[]> {
+    return unwrap(await this.svc.getServerDestinations(uuid));
+  }
+
+  async validate(uuid: string) {
+    return unwrap(await this.svc.validateServer(uuid));
+  }
+}
+
+class ProjectsResource {
+  constructor(private svc: CoolifyService) {}
+
+  async list(options?: IPaginationOptions): Promise<ICoolifyProject[]> {
+    return unwrap(await this.svc.listProjects(options?.page, options?.perPage));
+  }
+
+  async create(name: string, description?: string): Promise<ICoolifyProject> {
+    return unwrap(await this.svc.createProject(name, description));
+  }
+
+  async update(uuid: string, data: { name?: string; description?: string }) {
+    return unwrap(await this.svc.updateProject(uuid, data));
+  }
+
+  async delete(uuid: string) {
+    return unwrap(await this.svc.deleteProject(uuid));
+  }
+
+  async environments(projectUuid: string): Promise<ICoolifyEnvironment[]> {
+    return unwrap(await this.svc.getProjectEnvironments(projectUuid));
+  }
+
+  async createEnvironment(
+    projectUuid: string,
+    data: { name: string; description?: string },
+  ) {
+    return unwrap(await this.svc.createProjectEnvironment(projectUuid, data));
+  }
+}
+
+class TeamsResource {
+  constructor(private svc: CoolifyService) {}
+
+  async list(options?: IPaginationOptions): Promise<ICoolifyTeam[]> {
+    return unwrap(await this.svc.listTeams(options?.page, options?.perPage));
+  }
+
+  async current(): Promise<ICoolifyTeam> {
+    return unwrap(await this.svc.getCurrentTeam());
+  }
+
+  async get(id: number): Promise<ICoolifyTeam> {
+    return unwrap(await this.svc.getTeam(id));
+  }
+
+  async members(teamId: number) {
+    return unwrap(await this.svc.getTeamMembers(teamId));
+  }
+}
+
+class KeysResource {
+  constructor(private svc: CoolifyService) {}
+
+  async list(): Promise<ICoolifyPrivateKey[]> {
+    return unwrap(await this.svc.listPrivateKeys());
+  }
+
+  async get(uuid: string): Promise<ICoolifyPrivateKey> {
+    return unwrap(await this.svc.getPrivateKey(uuid));
+  }
+
+  async create(data: {
+    name: string;
+    private_key: string;
+    description?: string;
+  }) {
+    return unwrap(await this.svc.createPrivateKey(data));
+  }
+
+  async update(
+    uuid: string,
+    data: { name?: string; private_key?: string; description?: string },
+  ) {
+    return unwrap(await this.svc.updatePrivateKey(uuid, data));
+  }
+
+  async delete(uuid: string) {
+    return unwrap(await this.svc.deletePrivateKey(uuid));
+  }
+}
+
+class DeploymentsResource {
+  constructor(private svc: CoolifyService) {}
+
+  async active(options?: IPaginationOptions): Promise<ICoolifyDeployment[]> {
+    return unwrap(
+      await this.svc.listDeployments(options?.page, options?.perPage),
+    );
+  }
+
+  async get(uuid: string): Promise<ICoolifyDeployment> {
+    return unwrap(await this.svc.getDeployment(uuid));
+  }
+
+  /** Get deployment with build logs. */
+  async logs(uuid: string) {
+    return unwrap(await this.svc.getDeploymentLogs(uuid));
+  }
+
+  async cancel(uuid: string) {
+    return unwrap(await this.svc.cancelDeployment(uuid));
+  }
+}
+
+class DiagnoseResource {
+  constructor(private svc: CoolifyService) {}
+
+  async app(query: string) {
+    return unwrap(await this.svc.diagnoseApplication(query));
+  }
+
+  async server(query: string) {
+    return unwrap(await this.svc.diagnoseServer(query));
+  }
+
+  async infrastructure() {
+    return unwrap(await this.svc.findInfrastructureIssues());
+  }
+
+  /** Analyze a failed deployment — extracts errors from build logs. */
+  async deployFailure(deploymentUuid: string) {
+    const { analyzeDeployFailure } = await import("./network.js");
+    return unwrap(await analyzeDeployFailure(this.svc, deploymentUuid));
+  }
+}
+
+/**
+ * Network diagnostics — inspect Docker networks, proxy, DNS, connectivity.
+ */
+class NetworkResource {
+  constructor(private svc: CoolifyService) {}
+
+  /**
+   * Inspect container network environment.
+   *
+   * @param appUuid - Application UUID
+   * @param servicesToTest - Service names to test connectivity (e.g., ['db', 'redis'])
+   */
+  async inspect(appUuid: string, servicesToTest?: string[]) {
+    const { inspectNetwork } = await import("./network.js");
+    return unwrap(await inspectNetwork(this.svc, appUuid, servicesToTest));
+  }
+}
+
+class BatchResource {
+  constructor(private svc: CoolifyService) {}
+
+  async restartProject(projectUuid: string) {
+    return unwrap(await this.svc.restartProjectApps(projectUuid));
+  }
+
+  async redeployProject(projectUuid: string, force?: boolean) {
+    return unwrap(await this.svc.redeployProjectApps(projectUuid, force));
+  }
+
+  async stopAll() {
+    return unwrap(await this.svc.stopAllApps());
+  }
+}
+
+class GitHubAppsResource {
+  constructor(private svc: CoolifyService) {}
+
+  async list(options?: IPaginationOptions) {
+    return unwrap(
+      await this.svc.listGithubApps(options?.page, options?.perPage),
+    );
+  }
+
+  async create(data: Record<string, unknown>) {
+    return unwrap(await this.svc.createGitHubApp(data));
+  }
+
+  async update(id: number, data: Record<string, unknown>) {
+    return unwrap(await this.svc.updateGitHubApp(id, data));
+  }
+
+  async delete(id: number) {
+    return unwrap(await this.svc.deleteGitHubApp(id));
+  }
+}
+
+// ─── Main SDK Class ──────────────────────────────────────────────────────────
+
+/**
+ * Coolify SDK — The main entry point for interacting with a Coolify instance.
+ *
+ * Every parameter from the internal CoolifyService is exposed.
+ * Nothing is lost — progress callbacks, pagination, cascade deletes, all supported.
+ */
+export class Coolify {
+  /** @internal */
+  readonly svc: CoolifyService;
+  private initialized = false;
+
+  readonly applications: ApplicationsResource;
+  readonly databases: DatabasesResource;
+  readonly services: ServicesResource;
+  readonly servers: ServersResource;
+  readonly projects: ProjectsResource;
+  readonly teams: TeamsResource;
+  readonly keys: KeysResource;
+  readonly deployments: DeploymentsResource;
+  readonly diagnose: DiagnoseResource;
+  readonly network: NetworkResource;
+  readonly batch: BatchResource;
+  readonly githubApps: GitHubAppsResource;
+
+  constructor(options?: ICoolifyOptions) {
+    this.svc = new CoolifyService();
+
+    if (options) {
+      process.env.COOLIFY_URL = options.url;
+      process.env.COOLIFY_TOKEN = options.token;
+    }
+
+    const autoInit = <T extends object>(resource: T): T => {
+      return new Proxy(resource, {
+        get: (target, prop, receiver) => {
+          const value = Reflect.get(target, prop, receiver);
+          if (typeof value !== "function") return value;
+          return async (...args: unknown[]) => {
+            await this.ensureInit();
+            return (value as Function).apply(target, args);
+          };
+        },
+      });
+    };
+
+    this.applications = autoInit(new ApplicationsResource(this.svc));
+    this.databases = autoInit(new DatabasesResource(this.svc));
+    this.services = autoInit(new ServicesResource(this.svc));
+    this.servers = autoInit(new ServersResource(this.svc));
+    this.projects = autoInit(new ProjectsResource(this.svc));
+    this.teams = autoInit(new TeamsResource(this.svc));
+    this.keys = autoInit(new KeysResource(this.svc));
+    this.deployments = autoInit(new DeploymentsResource(this.svc));
+    this.diagnose = autoInit(new DiagnoseResource(this.svc));
+    this.network = autoInit(new NetworkResource(this.svc));
+    this.batch = autoInit(new BatchResource(this.svc));
+    this.githubApps = autoInit(new GitHubAppsResource(this.svc));
+  }
+
+  static fromEnv(): Coolify {
+    return new Coolify();
+  }
+
+  private async ensureInit(): Promise<void> {
+    if (this.initialized) return;
+    const initResult = await this.svc.init();
+    if (isErr(initResult)) {
+      throw new Error(`Coolify connection failed: ${initResult.error.message}`);
+    }
+    this.initialized = true;
+  }
+
+  async version(): Promise<ICoolifyVersion> {
+    await this.ensureInit();
+    return unwrap(await this.svc.getVersion());
+  }
+}

package/src/server/index.ts

@@ -0,0 +1,13 @@
+/**
+ * MCP Server barrel export.
+ *
+ * Use `stdio.ts` for Claude Desktop integration.
+ * Use `sse.ts` for web integrations.
+ *
+ * @module
+ */
+
+// Re-export nothing — server files are standalone entry points.
+// Import them directly:
+//   import './server/stdio.js'  // starts stdio server
+//   import './server/sse.js'    // starts SSE server

package/src/server/sse.ts

@@ -8,43 +8,51 @@
  * @module
  */
 
-import { createServer } from 'node:http'
+import { createServer } from "node:http";
 
-const PORT = process.env.PORT || 3000
+const PORT = process.env.PORT || 3000;
 
 const httpServer = createServer((req, res) => {
   // Set CORS headers
-  res.setHeader('Access-Control-Allow-Origin', '*')
-  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
-  res.setHeader('Access-Control-Allow-Headers', 'Content-Type')
-
-  if (req.method === 'OPTIONS') {
-    res.writeHead(200)
-    res.end()
-    return
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+  if (req.method === "OPTIONS") {
+    res.writeHead(200);
+    res.end();
+    return;
   }
 
   // Health check endpoint
-  if (req.url === '/health') {
-    res.writeHead(200, { 'Content-Type': 'application/json' })
-    res.end(JSON.stringify({ status: 'healthy', server: 'coolify-mcp' }))
-    return
+  if (req.url === "/health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "healthy", server: "coolify-mcp" }));
+    return;
   }
 
   // SSE endpoint - Note: This is a placeholder for future SSE support
-  if (req.url === '/sse') {
-    res.writeHead(200, { 'Content-Type': 'application/json' })
-    res.end(JSON.stringify({ message: 'SSE not yet implemented. Use stdio transport.' }))
-    return
+  if (req.url === "/sse") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        message: "SSE not yet implemented. Use stdio transport.",
+      }),
+    );
+    return;
   }
 
   // 404
-  res.writeHead(404, { 'Content-Type': 'application/json' })
-  res.end(JSON.stringify({ error: 'Not found' }))
-})
+  res.writeHead(404, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: "Not found" }));
+});
 
 httpServer.listen(PORT, () => {
-  console.warn(`Coolify MCP Server (SSE placeholder) listening on port ${PORT}`)
-  console.warn(`Health check: http://localhost:${PORT}/health`)
-  console.warn(`Note: SSE transport not yet implemented. Use stdio for Claude Desktop.`)
-})
+  console.warn(
+    `Coolify MCP Server (SSE placeholder) listening on port ${PORT}`,
+  );
+  console.warn(`Health check: http://localhost:${PORT}/health`);
+  console.warn(
+    `Note: SSE transport not yet implemented. Use stdio for Claude Desktop.`,
+  );
+});