synapse-mcp 1.0.0 → 1.0.2

package/dist/schemas/flux/index.d.ts

@@ -1,20 +1,512 @@
 import { z } from "zod";
+/**
+ * Host actions supported by Flux handlers.
+ * Excludes host:ports and host:doctor (schemas exist but handlers not yet wired).
+ */
+declare const fluxHostActionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"status">;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"resources">;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"info">;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"uptime">;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"services">;
+    host: z.ZodOptional<z.ZodString>;
+    service: z.ZodOptional<z.ZodString>;
+    state: z.ZodDefault<z.ZodEnum<{
+        running: "running";
+        stopped: "stopped";
+        all: "all";
+        failed: "failed";
+    }>>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"network">;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"mounts">;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>], "subaction">;
+/**
+ * Type for host actions supported by Flux handlers.
+ * Subset of HostActionInput - excludes ports and doctor (not yet implemented).
+ */
+export type FluxHostActionInput = z.infer<typeof fluxHostActionsSchema>;
+/** Total number of subactions in the Flux schema */
+export declare const FLUX_SUBACTION_COUNT = 41;
 /**
  * Flux Tool Schema - Docker infrastructure management
- *
- * Actions: 4 (container, compose, docker, host)
- * Subactions: 39 total
- *   - container: 14 (list, start, stop, restart, pause, resume, logs, stats, inspect, search, pull, recreate, exec, top)
- *   - compose: 9 (list, status, up, down, restart, logs, build, pull, recreate)
- *   - docker: 9 (info, df, prune, images, pull, build, rmi, networks, volumes)
- *   - host: 7 (status, resources, info, uptime, services, network, mounts)
- *
- * Uses composite discriminator: action_subaction (e.g., "container:list")
  */
-export declare const FluxSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDiscriminatedUnion<[z.ZodObject<any, z.core.$strip>, z.ZodObject<any, z.core.$strip>, ...z.ZodObject<any, z.core.$strip>[]], "action_subaction">>;
+export declare const FluxSchema: z.ZodUnion<readonly [z.ZodObject<{
+    action: z.ZodLiteral<"help">;
+    topic: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<{
+        json: "json";
+        markdown: "markdown";
+    }>>;
+}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"list">;
+    host: z.ZodOptional<z.ZodString>;
+    state: z.ZodDefault<z.ZodEnum<{
+        running: "running";
+        paused: "paused";
+        exited: "exited";
+        restarting: "restarting";
+        all: "all";
+    }>>;
+    name_filter: z.ZodOptional<z.ZodString>;
+    image_filter: z.ZodOptional<z.ZodString>;
+    label_filter: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"start">;
+    container_id: z.ZodString;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"stop">;
+    container_id: z.ZodString;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"restart">;
+    container_id: z.ZodString;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"pause">;
+    container_id: z.ZodString;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"resume">;
+    container_id: z.ZodString;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"logs">;
+    container_id: z.ZodString;
+    host: z.ZodOptional<z.ZodString>;
+    lines: z.ZodDefault<z.ZodNumber>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    grep: z.ZodOptional<z.ZodString>;
+    stream: z.ZodDefault<z.ZodEnum<{
+        stdout: "stdout";
+        stderr: "stderr";
+        both: "both";
+    }>>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"stats">;
+    container_id: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"inspect">;
+    container_id: z.ZodString;
+    host: z.ZodOptional<z.ZodString>;
+    summary: z.ZodDefault<z.ZodBoolean>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"search">;
+    query: z.ZodString;
+    host: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"pull">;
+    container_id: z.ZodString;
+    image: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"recreate">;
+    container_id: z.ZodString;
+    host: z.ZodOptional<z.ZodString>;
+    pull: z.ZodDefault<z.ZodBoolean>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"exec">;
+    container_id: z.ZodString;
+    host: z.ZodOptional<z.ZodString>;
+    command: z.ZodString;
+    user: z.ZodOptional<z.ZodString>;
+    workdir: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"container">;
+    subaction: z.ZodLiteral<"top">;
+    container_id: z.ZodString;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>], "subaction">, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    action: z.ZodLiteral<"compose">;
+    subaction: z.ZodLiteral<"list">;
+    host: z.ZodOptional<z.ZodString>;
+    name_filter: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    action: z.ZodLiteral<"compose">;
+    subaction: z.ZodLiteral<"status">;
+    host: z.ZodOptional<z.ZodString>;
+    project: z.ZodString;
+    service_filter: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"compose">;
+    subaction: z.ZodLiteral<"up">;
+    host: z.ZodOptional<z.ZodString>;
+    project: z.ZodString;
+    detach: z.ZodDefault<z.ZodBoolean>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"compose">;
+    subaction: z.ZodLiteral<"down">;
+    host: z.ZodOptional<z.ZodString>;
+    project: z.ZodString;
+    remove_volumes: z.ZodDefault<z.ZodBoolean>;
+    force: z.ZodDefault<z.ZodBoolean>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"compose">;
+    subaction: z.ZodLiteral<"restart">;
+    host: z.ZodOptional<z.ZodString>;
+    project: z.ZodString;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"compose">;
+    subaction: z.ZodLiteral<"logs">;
+    host: z.ZodOptional<z.ZodString>;
+    project: z.ZodString;
+    service: z.ZodOptional<z.ZodString>;
+    lines: z.ZodDefault<z.ZodNumber>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    grep: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"compose">;
+    subaction: z.ZodLiteral<"build">;
+    host: z.ZodOptional<z.ZodString>;
+    project: z.ZodString;
+    service: z.ZodOptional<z.ZodString>;
+    no_cache: z.ZodDefault<z.ZodBoolean>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"compose">;
+    subaction: z.ZodLiteral<"pull">;
+    host: z.ZodOptional<z.ZodString>;
+    project: z.ZodString;
+    service: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"compose">;
+    subaction: z.ZodLiteral<"recreate">;
+    host: z.ZodOptional<z.ZodString>;
+    project: z.ZodString;
+    service: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"compose">;
+    subaction: z.ZodLiteral<"refresh">;
+    host: z.ZodString;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>], "subaction">, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"docker">;
+    subaction: z.ZodLiteral<"info">;
+    host: z.ZodString;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"docker">;
+    subaction: z.ZodLiteral<"df">;
+    host: z.ZodString;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"docker">;
+    subaction: z.ZodLiteral<"prune">;
+    host: z.ZodString;
+    prune_target: z.ZodEnum<{
+        all: "all";
+        containers: "containers";
+        images: "images";
+        volumes: "volumes";
+        networks: "networks";
+        buildcache: "buildcache";
+    }>;
+    force: z.ZodDefault<z.ZodBoolean>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    action: z.ZodLiteral<"docker">;
+    subaction: z.ZodLiteral<"images">;
+    host: z.ZodOptional<z.ZodString>;
+    dangling_only: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"docker">;
+    subaction: z.ZodLiteral<"pull">;
+    host: z.ZodString;
+    image: z.ZodString;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"docker">;
+    subaction: z.ZodLiteral<"build">;
+    host: z.ZodString;
+    context: z.ZodString;
+    tag: z.ZodString;
+    dockerfile: z.ZodOptional<z.ZodString>;
+    no_cache: z.ZodDefault<z.ZodBoolean>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"docker">;
+    subaction: z.ZodLiteral<"rmi">;
+    host: z.ZodString;
+    image: z.ZodString;
+    force: z.ZodDefault<z.ZodBoolean>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    action: z.ZodLiteral<"docker">;
+    subaction: z.ZodLiteral<"networks">;
+    host: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    action: z.ZodLiteral<"docker">;
+    subaction: z.ZodLiteral<"volumes">;
+    host: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "subaction">, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"status">;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"resources">;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"info">;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"uptime">;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"services">;
+    host: z.ZodOptional<z.ZodString>;
+    service: z.ZodOptional<z.ZodString>;
+    state: z.ZodDefault<z.ZodEnum<{
+        running: "running";
+        stopped: "stopped";
+        all: "all";
+        failed: "failed";
+    }>>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"network">;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"host">;
+    subaction: z.ZodLiteral<"mounts">;
+    host: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodEnum<{
+        json: import("../../types.js").ResponseFormat.JSON;
+        markdown: import("../../types.js").ResponseFormat.MARKDOWN;
+    }>>;
+}, z.core.$strip>], "subaction">]>;
 export type FluxInput = z.infer<typeof FluxSchema>;
-export * from "./container.js";
 export * from "./compose.js";
+export * from "./container.js";
 export * from "./docker.js";
 export * from "./host.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/schemas/flux/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schemas/flux/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoHxB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,oMAGtB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAGnD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schemas/flux/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4BxB;;;GAGG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAQzB,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAExE,oDAAoD;AACpD,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAQ0E,CAAC;AAElG,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEnD,cAAc,cAAc,CAAC;AAE7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}

package/dist/schemas/flux/index.js

@@ -1,88 +1,52 @@
 // src/schemas/flux/index.ts
 import { z } from "zod";
-import { preprocessWithDiscriminator } from "../common.js";
-// Import all schemas
-import { containerListSchema, containerStartSchema, containerStopSchema, containerRestartSchema, containerPauseSchema, containerResumeSchema, containerLogsSchema, containerStatsSchema, containerInspectSchema, containerSearchSchema, containerPullSchema, containerRecreateSchema, containerExecSchema, containerTopSchema } from "./container.js";
-import { composeListSchema, composeStatusSchema, composeUpSchema, composeDownSchema, composeRestartSchema, composeLogsSchema, composeBuildSchema, composePullSchema, composeRecreateSchema } from "./compose.js";
-import { dockerInfoSchema, dockerDfSchema, dockerPruneSchema, dockerImagesSchema, dockerPullSchema, dockerBuildSchema, dockerRmiSchema, dockerNetworksSchema, dockerVolumesSchema } from "./docker.js";
-import { hostStatusSchema, hostResourcesSchema, hostInfoSchema, hostUptimeSchema, hostServicesSchema, hostNetworkSchema, hostMountsSchema } from "./host.js";
+import { composeActionsSchema } from "./compose.js";
+import { containerActionsSchema } from "./container.js";
+import { dockerActionsSchema } from "./docker.js";
+import { hostInfoSchema, hostMountsSchema, hostNetworkSchema, hostResourcesSchema, hostServicesSchema, hostStatusSchema, hostUptimeSchema, } from "./host.js";
 /**
- * Extract inner schema from z.preprocess wrapper
- * Handles both Zod 3.x (innerType) and Zod 4.x (pipe structure)
+ * Help schema - provides auto-generated documentation.
  */
-function unwrapPreprocess(schema) {
-    const def = schema._def;
-    // Zod 4.x: z.preprocess creates a pipe with type='pipe' and out field
-    if (def?.type === 'pipe' && def?.out)
-        return def.out;
-    // Zod 3.x uses 'innerType'
-    if (def?.innerType)
-        return def.innerType;
-    // Return as-is if not wrapped
-    return schema;
-}
-// All inner schemas (unwrapped from preprocess)
-const allSchemas = [
-    // Container (14)
-    containerListSchema,
-    containerStartSchema,
-    containerStopSchema,
-    containerRestartSchema,
-    containerPauseSchema,
-    containerResumeSchema,
-    containerLogsSchema,
-    containerStatsSchema,
-    containerInspectSchema,
-    containerSearchSchema,
-    containerPullSchema,
-    containerRecreateSchema,
-    containerExecSchema,
-    containerTopSchema,
-    // Compose (9)
-    composeListSchema,
-    composeStatusSchema,
-    composeUpSchema,
-    composeDownSchema,
-    composeRestartSchema,
-    composeLogsSchema,
-    composeBuildSchema,
-    composePullSchema,
-    composeRecreateSchema,
-    // Docker (9)
-    dockerInfoSchema,
-    dockerDfSchema,
-    dockerPruneSchema,
-    dockerImagesSchema,
-    dockerPullSchema,
-    dockerBuildSchema,
-    dockerRmiSchema,
-    dockerNetworksSchema,
-    dockerVolumesSchema,
-    // Host (7)
+const helpSchema = z
+    .object({
+    action: z.literal("help").describe("Show auto-generated documentation"),
+    topic: z
+        .string()
+        .optional()
+        .describe("Optional: filter to specific topic (e.g., 'container:list')"),
+    format: z.enum(["markdown", "json"]).optional().describe("Output format (default: markdown)"),
+})
+    .describe("Get auto-generated help documentation for flux tool");
+/**
+ * Host actions supported by Flux handlers.
+ * Excludes host:ports and host:doctor (schemas exist but handlers not yet wired).
+ */
+const fluxHostActionsSchema = z.discriminatedUnion("subaction", [
     hostStatusSchema,
     hostResourcesSchema,
     hostInfoSchema,
     hostUptimeSchema,
     hostServicesSchema,
     hostNetworkSchema,
-    hostMountsSchema
-].map(unwrapPreprocess);
+    hostMountsSchema,
+]);
+/** Total number of subactions in the Flux schema */
+export const FLUX_SUBACTION_COUNT = 41;
 /**
  * Flux Tool Schema - Docker infrastructure management
- *
- * Actions: 4 (container, compose, docker, host)
- * Subactions: 39 total
- *   - container: 14 (list, start, stop, restart, pause, resume, logs, stats, inspect, search, pull, recreate, exec, top)
- *   - compose: 9 (list, status, up, down, restart, logs, build, pull, recreate)
- *   - docker: 9 (info, df, prune, images, pull, build, rmi, networks, volumes)
- *   - host: 7 (status, resources, info, uptime, services, network, mounts)
- *
- * Uses composite discriminator: action_subaction (e.g., "container:list")
  */
-export const FluxSchema = z.preprocess(preprocessWithDiscriminator, z.discriminatedUnion("action_subaction", allSchemas));
+export const FluxSchema = z
+    .union([
+    helpSchema,
+    containerActionsSchema,
+    composeActionsSchema,
+    dockerActionsSchema,
+    fluxHostActionsSchema,
+])
+    .describe("Docker infrastructure management - container, compose, docker, and host operations");
+export * from "./compose.js";
 // Re-export all schemas
 export * from "./container.js";
-export * from "./compose.js";
 export * from "./docker.js";
 export * from "./host.js";
 //# sourceMappingURL=index.js.map

package/dist/schemas/flux/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/schemas/flux/index.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAE3D,qBAAqB;AACrB,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACpB,sBAAsB,EACtB,qBAAqB,EACrB,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,WAAW,CAAC;AAEnB;;;GAGG;AACH,SAAS,gBAAgB,CAAC,MAAoB;IAC5C,MAAM,GAAG,GAAI,MAAc,CAAC,IAAI,CAAC;IACjC,sEAAsE;IACtE,IAAI,GAAG,EAAE,IAAI,KAAK,MAAM,IAAI,GAAG,EAAE,GAAG;QAAE,OAAO,GAAG,CAAC,GAAG,CAAC;IACrD,2BAA2B;IAC3B,IAAI,GAAG,EAAE,SAAS;QAAE,OAAO,GAAG,CAAC,SAAS,CAAC;IACzC,8BAA8B;IAC9B,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,gDAAgD;AAChD,MAAM,UAAU,GAAG;IACjB,iBAAiB;IACjB,mBAAmB;IACnB,oBAAoB;IACpB,mBAAmB;IACnB,sBAAsB;IACtB,oBAAoB;IACpB,qBAAqB;IACrB,mBAAmB;IACnB,oBAAoB;IACpB,sBAAsB;IACtB,qBAAqB;IACrB,mBAAmB;IACnB,uBAAuB;IACvB,mBAAmB;IACnB,kBAAkB;IAClB,cAAc;IACd,iBAAiB;IACjB,mBAAmB;IACnB,eAAe;IACf,iBAAiB;IACjB,oBAAoB;IACpB,iBAAiB;IACjB,kBAAkB;IAClB,iBAAiB;IACjB,qBAAqB;IACrB,aAAa;IACb,gBAAgB;IAChB,cAAc;IACd,iBAAiB;IACjB,kBAAkB;IAClB,gBAAgB;IAChB,iBAAiB;IACjB,eAAe;IACf,oBAAoB;IACpB,mBAAmB;IACnB,WAAW;IACX,gBAAgB;IAChB,mBAAmB;IACnB,cAAc;IACd,gBAAgB;IAChB,kBAAkB;IAClB,iBAAiB;IACjB,gBAAgB;CACjB,CAAC,GAAG,CAAC,gBAAgB,CAAgE,CAAC;AAEvF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,UAAU,CACpC,2BAA2B,EAC3B,CAAC,CAAC,kBAAkB,CAAC,kBAAkB,EAAE,UAAU,CAAC,CACrD,CAAC;AAIF,wBAAwB;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/schemas/flux/index.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,WAAW,CAAC;AAEnB;;GAEG;AACH,MAAM,UAAU,GAAG,CAAC;KACjB,MAAM,CAAC;IACN,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,mCAAmC,CAAC;IACvE,KAAK,EAAE,CAAC;SACL,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CAAC,6DAA6D,CAAC;IAC1E,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,mCAAmC,CAAC;CAC9F,CAAC;KACD,QAAQ,CAAC,qDAAqD,CAAC,CAAC;AAEnE;;;GAGG;AACH,MAAM,qBAAqB,GAAG,CAAC,CAAC,kBAAkB,CAAC,WAAW,EAAE;IAC9D,gBAAgB;IAChB,mBAAmB;IACnB,cAAc;IACd,gBAAgB;IAChB,kBAAkB;IAClB,iBAAiB;IACjB,gBAAgB;CACjB,CAAC,CAAC;AAQH,oDAAoD;AACpD,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC;AAEvC;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC;KACxB,KAAK,CAAC;IACL,UAAU;IACV,sBAAsB;IACtB,oBAAoB;IACpB,mBAAmB;IACnB,qBAAqB;CACtB,CAAC;KACD,QAAQ,CAAC,oFAAoF,CAAC,CAAC;AAIlG,cAAc,cAAc,CAAC;AAC7B,wBAAwB;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}