@mks2508/coolify-mks-cli-mcp 0.1.0

package/dist/tools/definitions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * MCP Tool definitions for Coolify.
+ *
+ * Defines all 21 tools with their input schemas.
+ *
+ * @module
+ */
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * All Coolify MCP tool definitions.
+ */
+export declare const coolifyTools: Tool[];
+//# sourceMappingURL=definitions.d.ts.map

package/dist/tools/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/tools/definitions.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAA;AAE9D;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,IAAI,EAqa9B,CAAA"}

package/dist/tools/handlers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * MCP Tool handlers for Coolify.
+ *
+ * Handles execution of all 21 Coolify MCP tools.
+ *
+ * @module
+ */
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CoolifyService } from '../coolify/index.js';
+/**
+ * Handler function for tool calls.
+ *
+ * @param name - Tool name
+ * @param args - Tool arguments
+ * @param coolify - CoolifyService instance
+ * @returns Tool call result
+ */
+export declare function handleToolCall(name: string, args: Record<string, unknown>, coolify: CoolifyService): Promise<CallToolResult>;
+//# sourceMappingURL=handlers.d.ts.map

package/dist/tools/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/tools/handlers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAA;AAExE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEzD;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,cAAc,CAAC,CA0DzB"}

package/dist/utils/format.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Formatting utilities for CLI output.
+ *
+ * Provides table formatting and color helpers.
+ *
+ * @module
+ */
+import Table from 'cli-table3';
+/**
+ * Creates a formatted table with headers.
+ *
+ * @param headers - Column headers
+ * @param colWidths - Optional column widths
+ * @returns Configured Table instance
+ */
+export declare function createTable(headers: string[], colWidths?: number[]): Table.Table;
+/**
+ * Formats application status with colored indicator.
+ *
+ * @param status - Application status string
+ * @returns Formatted status string
+ */
+export declare function formatStatus(status: string): string;
+/**
+ * Formats bytes to human-readable format.
+ *
+ * @param bytes - Number of bytes
+ * @returns Formatted string with unit
+ */
+export declare function formatBytes(bytes: number): string;
+/**
+ * Formats timestamp to relative time.
+ *
+ * @param timestamp - ISO timestamp string
+ * @returns Relative time string
+ */
+export declare function formatRelativeTime(timestamp: string): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/utils/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/utils/format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,MAAM,YAAY,CAAA;AAY9B;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,eAOlE;AAgBD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAWnD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQjD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAY5D"}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@mks2508/coolify-mks-cli-mcp",
+  "version": "0.1.0",
+  "description": "MCP server and CLI for Coolify deployment management",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "coolify-mcp": "./dist/cli/index.js",
+    "coolify-mcp-server": "./dist/server/stdio.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./coolify": {
+      "types": "./dist/coolify/index.d.ts",
+      "import": "./dist/coolify/index.js"
+    },
+    "./tools": {
+      "types": "./dist/tools/definitions.d.ts",
+      "import": "./dist/tools/definitions.js"
+    },
+    "./server": {
+      "types": "./dist/server/stdio.d.ts",
+      "import": "./dist/server/stdio.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "dev": "bun --watch src/index.ts",
+    "dev:mcp": "bun --watch src/server/stdio.ts",
+    "dev:sse": "bun --watch src/server/sse.ts",
+    "dev:cli": "bun --watch src/cli/index.ts",
+    "build": "bun run build:mcp && bun run build:cli",
+    "build:mcp": "rolldown --config rolldown.config.ts && tsc --project tsconfig.build.json",
+    "build:cli": "bun build ./src/cli/index.ts --outdir ./dist/cli --target node && bun build ./src/server/stdio.ts --outdir ./dist/server --target node && bun build ./src/server/sse.ts --outdir ./dist/server --target node",
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.1",
+    "@mks2508/better-logger": "^4.0.0",
+    "@mks2508/no-throw": "^0.1.0",
+    "@modelcontextprotocol/sdk": "^1.25.2",
+    "chalk": "^5.4.1",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "ora": "^8.1.1",
+    "prompts": "^2.4.2",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "@types/prompts": "^2.4.9",
+    "rolldown": "^1.0.0-beta.58",
+    "typescript": "^5.8.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/cli/commands/config.ts

@@ -0,0 +1,83 @@
+/**
+ * Config command for CLI.
+ *
+ * @module
+ */
+
+import { isOk } from '@mks2508/no-throw'
+import chalk from 'chalk'
+import { existsSync } from 'node:fs'
+import { loadConfig, saveConfig, CONFIG_FILE } from '../../coolify/config.js'
+
+/**
+ * Config command handler.
+ *
+ * @param action - Config action (set, get, path)
+ * @param args - Action arguments
+ */
+export async function configCommand(
+  action: string | undefined,
+  args: { key?: string; value?: string }
+) {
+  if (action === 'set') {
+    if (!args.key || !args.value) {
+      console.error(chalk.red('Error: key and value are required for "set" command'))
+      console.log(chalk.gray('Usage: coolify-mcp config set <key> <value>'))
+      console.log(chalk.gray('Keys: url, token'))
+      return
+    }
+
+    const result = await loadConfig()
+    if (isOk(result)) {
+      const config = result.value
+      if (args.key === 'url') {
+        config.url = args.value
+      } else if (args.key === 'token') {
+        config.token = args.value
+      } else {
+        console.error(chalk.red(`Error: Unknown key "${args.key}"`))
+        return
+      }
+
+      const saveResult = await saveConfig(config)
+      if (isOk(saveResult)) {
+        console.log(chalk.green(`Config updated: ${args.key} = ${args.value}`))
+      } else {
+        console.error(chalk.red(`Error: ${saveResult.error.message}`))
+      }
+    }
+  } else if (action === 'get') {
+    const result = await loadConfig()
+    if (isOk(result)) {
+      const config = result.value
+      console.log(chalk.cyan('Current configuration:'))
+      console.log(`  URL: ${chalk.gray(config.url || '(not set)')}`)
+      console.log(`  Token: ${chalk.gray(config.token ? '(set)' : '(not set)')}`)
+    } else {
+      console.error(chalk.red(`Error: ${result.error.message}`))
+    }
+  } else if (action === 'path') {
+    console.log(chalk.cyan('Config file:'))
+    console.log(`  ${CONFIG_FILE}`)
+    if (existsSync(CONFIG_FILE)) {
+      console.log(chalk.gray('  Status: File exists'))
+    } else {
+      console.log(chalk.yellow('  Status: File does not exist'))
+    }
+  } else {
+    console.log(chalk.cyan('Coolify MCP Configuration'))
+    console.log()
+    console.log(chalk.gray('Commands:'))
+    console.log('  coolify-mcp config set <key> <value>  Set a config value')
+    console.log('  coolify-mcp config get                 Show current config')
+    console.log('  coolify-mcp config path                Show config file path')
+    console.log()
+    console.log(chalk.gray('Keys:'))
+    console.log('  url    - Coolify instance URL')
+    console.log('  token  - Coolify API token')
+    console.log()
+    console.log(chalk.gray('Environment variables:'))
+    console.log('  COOLIFY_URL     - Coolify instance URL')
+    console.log('  COOLIFY_TOKEN   - Coolify API token')
+  }
+}

package/src/cli/commands/deploy.ts

@@ -0,0 +1,56 @@
+/**
+ * Deploy command for CLI.
+ *
+ * @module
+ */
+
+import { isOk, isErr } from '@mks2508/no-throw'
+import ora from 'ora'
+import chalk from 'chalk'
+import { getCoolifyService } from '../../coolify/index.js'
+
+/**
+ * Deploy command handler.
+ *
+ * @param uuid - Application UUID
+ * @param options - Deploy options
+ */
+export async function deployCommand(uuid: string, options: { force?: boolean; tag?: string }) {
+  const spinner = ora('Initializing Coolify connection...').start()
+
+  try {
+    const coolify = getCoolifyService()
+    const initResult = await coolify.init()
+
+    if (isErr(initResult)) {
+      spinner.fail(chalk.red(`Failed to initialize: ${initResult.error.message}`))
+      return
+    }
+
+    spinner.text = 'Triggering deployment...'
+
+    const result = await coolify.deploy(
+      {
+        uuid,
+        force: options.force,
+        tag: options.tag,
+      },
+      (percent, message) => {
+        spinner.text = `${chalk.bold(`[${percent}%]`)} ${message}`
+      }
+    )
+
+    if (isOk(result)) {
+      spinner.succeed(
+        chalk.green(`Deployment triggered! UUID: ${chalk.cyan(result.value.deploymentUuid?.slice(0, 8))}`)
+      )
+      console.log(`  Resource UUID: ${chalk.cyan(result.value.resourceUuid?.slice(0, 8))}`)
+    } else {
+      spinner.fail(chalk.red(`Deployment failed: ${result.error.message}`))
+    }
+  } catch (error) {
+    spinner.fail(
+      chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`)
+    )
+  }
+}

package/src/cli/commands/env.ts

@@ -0,0 +1,60 @@
+/**
+ * Env vars command for CLI.
+ *
+ * @module
+ */
+
+import { isErr } from '@mks2508/no-throw'
+import chalk from 'chalk'
+import { getCoolifyService } from '../../coolify/index.js'
+
+/**
+ * Env vars command handler.
+ *
+ * @param uuid - Application UUID
+ */
+export async function envCommand(uuid: string) {
+  const coolify = getCoolifyService()
+  const initResult = await coolify.init()
+
+  if (isErr(initResult)) {
+    console.error(chalk.red(`Error: ${initResult.error.message}`))
+    return
+  }
+
+  const result = await coolify.getEnvironmentVariables(uuid)
+
+  if (isErr(result)) {
+    console.error(chalk.red(`Error: ${result.error.message}`))
+    return
+  }
+
+  const envVars = result.value
+
+  if (envVars.length === 0) {
+    console.log(chalk.yellow('No environment variables found'))
+    return
+  }
+
+  console.log(chalk.cyan(`Environment variables (${envVars.length}):\n`))
+
+  // Separar runtime de buildtime
+  const runtimeVars = envVars.filter(ev => ev.is_runtime)
+  const buildtimeVars = envVars.filter(ev => ev.is_buildtime)
+
+  if (runtimeVars.length > 0) {
+    console.log(chalk.yellow.bold('Runtime:'))
+    for (const ev of runtimeVars) {
+      const required = ev.is_required ? chalk.red(' *') : ''
+      console.log(`  ${chalk.green(ev.key)}${required} = ${chalk.gray(ev.value)}`)
+    }
+    console.log()
+  }
+
+  if (buildtimeVars.length > 0) {
+    console.log(chalk.blue.bold('Buildtime:'))
+    for (const ev of buildtimeVars) {
+      console.log(`  ${chalk.green(ev.key)} = ${chalk.gray(ev.value)}`)
+    }
+  }
+}

package/src/cli/commands/list.ts

@@ -0,0 +1,63 @@
+/**
+ * List command for CLI.
+ *
+ * @module
+ */
+
+import { isErr } from '@mks2508/no-throw'
+import chalk from 'chalk'
+import Table from 'cli-table3'
+import { getCoolifyService } from '../../coolify/index.js'
+import { formatStatus } from '../../utils/format.js'
+
+/**
+ * List command handler.
+ *
+ * @param options - List options
+ */
+export async function listCommand(options: { team?: string; project?: string }) {
+  const coolify = getCoolifyService()
+  const initResult = await coolify.init()
+
+  if (isErr(initResult)) {
+    console.error(chalk.red(`Error: ${initResult.error.message}`))
+    return
+  }
+
+  const result = await coolify.listApplications(options.team, options.project)
+
+  if (isErr(result)) {
+    console.error(chalk.red(`Error: ${result.error.message}`))
+    return
+  }
+
+  const apps = result.value
+
+  if (apps.length === 0) {
+    console.log(chalk.yellow('No applications found'))
+    return
+  }
+
+  // Usar ancho dinámico basado en el contenido
+  const table = new Table({
+    head: [
+      chalk.cyan('UUID'),
+      chalk.cyan('Name'),
+      chalk.cyan('Status'),
+      chalk.cyan('Server')
+    ],
+    // Sin anchos fijos, dejar que cli-table3 auto-ajuste
+  })
+
+  for (const app of apps) {
+    table.push([
+      app.uuid,
+      app.name,
+      formatStatus(app.status),
+      app.destination?.server?.name || 'N/A',
+    ])
+  }
+
+  console.log(table.toString())
+  console.log(chalk.gray(`Total: ${apps.length} application(s)`))
+}

package/src/cli/commands/logs.ts

@@ -0,0 +1,49 @@
+/**
+ * Logs command for CLI.
+ *
+ * @module
+ */
+
+import { isErr } from '@mks2508/no-throw'
+import chalk from 'chalk'
+import { getCoolifyService } from '../../coolify/index.js'
+
+/**
+ * Logs command handler.
+ *
+ * @param uuid - Application UUID
+ * @param options - Logs options
+ */
+export async function logsCommand(uuid: string, options: { lines?: number; follow?: boolean }) {
+  const coolify = getCoolifyService()
+  const initResult = await coolify.init()
+
+  if (isErr(initResult)) {
+    console.error(chalk.red(`Error: ${initResult.error.message}`))
+    return
+  }
+
+  const result = await coolify.getApplicationLogs(uuid, { tail: options.lines || 50 })
+
+  if (isErr(result)) {
+    console.error(chalk.red(`Error: ${result.error.message}`))
+    return
+  }
+
+  const logs = result.value
+
+  if (logs.logs.length === 0) {
+    console.log(chalk.yellow('No logs available'))
+    return
+  }
+
+  console.log(chalk.gray(`Application logs (${logs.logs.length} lines):\n`))
+
+  for (const line of logs.logs) {
+    console.log(line)
+  }
+
+  if (options.follow) {
+    console.log(chalk.yellow('\nFollow mode not yet implemented'))
+  }
+}

package/src/cli/commands/servers.ts

@@ -0,0 +1,52 @@
+/**
+ * Servers command for CLI.
+ *
+ * @module
+ */
+
+import { isErr } from '@mks2508/no-throw'
+import chalk from 'chalk'
+import { getCoolifyService } from '../../coolify/index.js'
+import { createTable } from '../../utils/format.js'
+
+/**
+ * Servers command handler.
+ */
+export async function serversCommand() {
+  const coolify = getCoolifyService()
+  const initResult = await coolify.init()
+
+  if (isErr(initResult)) {
+    console.error(chalk.red(`Error: ${initResult.error.message}`))
+    return
+  }
+
+  const result = await coolify.listServers()
+
+  if (isErr(result)) {
+    console.error(chalk.red(`Error: ${result.error.message}`))
+    return
+  }
+
+  const servers = result.value
+
+  if (servers.length === 0) {
+    console.log(chalk.yellow('No servers found'))
+    return
+  }
+
+  const table = createTable(['UUID', 'Name', 'IP', 'Status'], [36, 25, 20, 15])
+
+  for (const server of servers) {
+    const statusColor = server.is_usable ? chalk.green : chalk.red
+    table.push([
+      server.uuid.slice(0, 8),
+      server.name,
+      server.ip || 'N/A',
+      statusColor(server.is_usable ? '● Usable' : '○ Unusable'),
+    ])
+  }
+
+  console.log(table.toString())
+  console.log(chalk.gray(`Total: ${servers.length} server(s)`))
+}

package/src/cli/index.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/**
+ * Coolify MCP CLI - Entry point.
+ *
+ * Command-line interface for Coolify deployment management.
+ *
+ * @module
+ */
+
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { deployCommand } from './commands/deploy.js'
+import { listCommand } from './commands/list.js'
+import { logsCommand } from './commands/logs.js'
+import { serversCommand } from './commands/servers.js'
+import { configCommand } from './commands/config.js'
+import { envCommand } from './commands/env.js'
+
+const program = new Command()
+
+program
+  .name('coolify-mcp')
+  .description('CLI for Coolify deployment management')
+  .version('0.1.0')
+
+// Config command
+program
+  .command('config')
+  .description('Manage configuration')
+  .argument('[action]', 'Action to perform (set, get, path)')
+  .option('--key <key>', 'Configuration key (for "set" action)')
+  .option('--value <value>', 'Configuration value (for "set" action)')
+  .action(configCommand)
+
+// List applications
+program
+  .command('list')
+  .description('List all applications')
+  .option('-t, --team <id>', 'Filter by team ID')
+  .option('-p, --project <id>', 'Filter by project ID')
+  .action(listCommand)
+
+// Deploy application
+program
+  .command('deploy <uuid>')
+  .description('Deploy an application')
+  .option('-f, --force', 'Force rebuild without cache')
+  .option('-t, --tag <tag>', 'Deploy specific tag/version')
+  .action(deployCommand)
+
+// Logs command
+program
+  .command('logs <uuid>')
+  .description('Get application logs')
+  .option('-n, --lines <number>', 'Number of lines to retrieve', '50')
+  .option('-f, --follow', 'Follow logs in real-time')
+  .action((uuid, options) => {
+    const lines = parseInt(options.lines, 10)
+    logsCommand(uuid, { lines, follow: options.follow })
+  })
+
+// Servers command
+program
+  .command('servers')
+  .description('List available servers')
+  .action(serversCommand)
+
+// Env vars command
+program
+  .command('env <uuid>')
+  .description('Get environment variables for an application')
+  .action(envCommand)
+
+// Show help by default
+program.action(() => {
+  console.log(chalk.cyan('Coolify MCP CLI'))
+  console.log(chalk.gray('Manage Coolify deployments from the command line\n'))
+  program.help()
+})
+
+program.parse()