feat(dokploy): cover complete MCP action catalog (#85)

## Summary

- add exact coverage for all 524 tools committed in
`Dokploy/mcp@db18449eafdfc8dbd438d392b95c46292069c658`
- expose a static, searchable action catalog split across 48 Dokploy
domains, backed by one lazy shared runtime
- preserve Dokploy MCP tool names and request schemas, with 186 GET
actions and 338 POST actions
- support the two multipart tools through OpenConnector transit files:
  - `application-dropDeployment`
  - `docker-uploadFileToContainer`
- keep `x-api-key` authentication, public-instance URL validation,
request timeouts, bounded responses, and redacted error details

## Scope

This PR targets the generated tool catalog committed in the pinned
Dokploy MCP revision above. It does **not** claim parity with Dokploy's
newer repository-root OpenAPI document, which currently contains
additional endpoints that are not yet part of that MCP catalog.

All 524 actions are statically defined and locally executable; this does
not add an unrestricted API proxy. Operations that can remove, stop, or
otherwise disrupt resources receive an explicit warning when the
upstream specification does not provide a description.

## Reproducible generation

`npm run generate:provider -- dokploy` dispatches to the provider-owned
generator, which downloads the pinned generated OpenAPI document and
verifies SHA-256
`225972ade1e545cc9a44638e4ff32d73a23ea48298617ca3a37fb5cfff6a058e`
before generating and formatting the 48 domain modules. Additional
arguments are forwarded only to that generator. An optional local source
is accepted only when it has the same digest. The generation pipeline
was run twice with identical output.

## Generated-schema exception

The repository guideline normally prefers hand-authored `s` schema
helpers for provider definitions. This PR requests a deliberate
large-provider exception, following the existing generated-provider
precedent used by integrations such as UnifAPI and Postman:

- 524 upstream schemas are too large and change-prone to maintain safely
by hand
- the source is pinned by commit and content hash
- generated output is split by domain instead of placed in one
monolithic file
- an independent 524-name snapshot test detects missing, duplicate, or
renamed MCP tools
- parity tests also enforce 48 tags, action/handler coverage,
representative schema constraints, and exactly two multipart operations

## Runtime behavior

- maps path, repeated query, JSON-body, and multipart fields from static
operation metadata
- preserves successful token and SSH-key responses; only error details
are recursively redacted
- limits response bodies to 10 MiB and error messages to 16 KiB
- preserves upstream error statuses, including bounded plain-text error
responses
- requires a public HTTP(S) Dokploy instance URL and rejects embedded
credentials and private/reserved targets

## Validation

- Dokploy generation pipeline: 524 actions / 48 domains / 0 unsupported;
repeated run produced identical output
- provider registry and catalog generation: 1,064 apps / 10,768 actions
- TypeScript checks: `src`, `scripts-all`, and `examples` passed
- lint and formatting checks passed
- full test suite: 38 files / 246 tests passed

Author: LJAYi

package.json

@@ -19,6 +19,7 @@
     "typecheck": "npm run generate:registry && node scripts/typecheck.ts src scripts-all examples",
     "generate:registry": "node scripts/generate-provider-registry.ts",
     "generate:catalog": "npm run generate:registry && node scripts/generate-catalog.ts",
+    "generate:provider": "node scripts/generate-provider.ts",
     "runtime:data": "node scripts/runtime-data.ts",
     "lint": "oxlint .",
     "lint:fix": "oxlint . --fix",

scripts/generate-provider.ts

@@ -0,0 +1,31 @@
+import { spawnSync } from "node:child_process";
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import { assertProviderId } from "../src/core/provider-id.ts";
+
+const [provider, ...generatorArguments] = process.argv.slice(2);
+if (!provider) {
+  throw new Error("Usage: npm run generate:provider -- <provider> [...generator arguments]");
+}
+
+assertProviderId(provider, "provider generator id");
+const generatorPath = join(process.cwd(), "src/providers", provider, "generate.ts");
+if (!(await isFile(generatorPath))) {
+  throw new Error(`Provider does not define a generator: ${provider}`);
+}
+
+const result = spawnSync(process.execPath, [generatorPath, ...generatorArguments], {
+  cwd: process.cwd(),
+  stdio: "inherit",
+});
+if (result.error) throw result.error;
+if (result.status !== 0) process.exit(result.status ?? 1);
+
+async function isFile(path: string): Promise<boolean> {
+  try {
+    return (await stat(path)).isFile();
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+    throw error;
+  }
+}

src/providers/dokploy/actions.ts

@@ -0,0 +1,17 @@
+import type { ProviderActionDefinition } from "../../core/provider-definition.ts";
+
+import { defineProviderAction } from "../../core/provider-definition.ts";
+import { dokployOperations } from "./operations.ts";
+
+export type { DokployActionName } from "./operations.ts";
+
+const service = "dokploy";
+
+export const dokployActions: ProviderActionDefinition[] = dokployOperations.map((operation) =>
+  defineProviderAction(service, {
+    name: operation.name,
+    description: operation.description,
+    inputSchema: operation.inputSchema,
+    outputSchema: operation.outputSchema,
+  }),
+);

src/providers/dokploy/definition.ts

@@ -0,0 +1,36 @@
+import type { ProviderDefinition } from "../../core/types.ts";
+
+import { dokployActions } from "./actions.ts";
+
+const service = "dokploy";
+
+export const provider: ProviderDefinition = {
+  service,
+  displayName: "Dokploy",
+  description: "Manage infrastructure, services, deployments, access, and settings on a self-hosted Dokploy instance.",
+  categories: ["Developer Tools", "Infrastructure"],
+  authTypes: ["api_key"],
+  auth: [
+    {
+      type: "api_key",
+      label: "API Key",
+      placeholder: "Enter your Dokploy API key",
+      description:
+        "An API key created from the Dokploy dashboard under Settings > API Keys. The key is sent in the x-api-key header.",
+      extraFields: [
+        {
+          key: "baseUrl",
+          label: "Instance URL",
+          inputType: "text",
+          required: true,
+          secret: false,
+          placeholder: "https://dokploy.example.com",
+          description:
+            "The public HTTP or HTTPS URL of your Dokploy instance, without an API endpoint path. See https://docs.dokploy.com/docs/core/api.",
+        },
+      ],
+    },
+  ],
+  homepageUrl: "https://dokploy.com",
+  actions: dokployActions,
+};

src/providers/dokploy/executors.ts

@@ -0,0 +1,28 @@
+import type {
+  CredentialValidationResult,
+  CredentialValidators,
+  ExecutionContext,
+  ProviderExecutors,
+} from "../../core/types.ts";
+import type { DokployActionContext } from "./runtime.ts";
+
+import { defineProviderExecutors, requireApiKeyCredential } from "../provider-runtime.ts";
+import { createDokployContext, dokployActionHandlers, validateDokployCredential } from "./runtime.ts";
+
+const service = "dokploy";
+
+export const executors: ProviderExecutors = defineProviderExecutors<DokployActionContext>({
+  service,
+  handlers: dokployActionHandlers,
+  async createContext(context: ExecutionContext, fetcher: typeof fetch): Promise<DokployActionContext> {
+    const credential = await requireApiKeyCredential(context, service);
+    return createDokployContext(credential.values, credential.apiKey, fetcher, context.signal, context.transitFiles);
+  },
+  fallbackMessage: "Dokploy request failed",
+});
+
+export const credentialValidators: CredentialValidators = {
+  apiKey(input, { fetcher, signal }): Promise<CredentialValidationResult> {
+    return validateDokployCredential(input.values, input.apiKey, fetcher, signal);
+  },
+};