@vibecodetown/mcp-server 1.3.1

package/build/mcp/cockpit-bridge/tools/decide.js

@@ -0,0 +1,62 @@
+/**
+ * cockpit.decide MCP Tool
+ * Submit LOOP/DIAGNOSE decision
+ */
+import { cockpitDecide, isCockpitdAvailable } from "../client.js";
+export const cockpitDecideTool = {
+    name: "cockpit.decide",
+    description: "Submit a decision when cockpitd is blocked (LOOP to retry, DIAGNOSE to analyze)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            choice: {
+                type: "string",
+                enum: ["LOOP", "DIAGNOSE", "A", "B"],
+                description: "Decision choice: LOOP/A (retry with user approval) or DIAGNOSE/B (analyze and stop)",
+            },
+        },
+        required: ["choice"],
+    },
+    handler: async (args) => {
+        if (!(await isCockpitdAvailable())) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "[OFFLINE] cockpitd is not running. Start it with: ./cockpitd",
+                    },
+                ],
+            };
+        }
+        // Normalize choice
+        const normalizedChoice = args.choice.toUpperCase() === "A" ||
+            args.choice.toUpperCase() === "LOOP"
+            ? "LOOP"
+            : "DIAGNOSE";
+        const result = await cockpitDecide(normalizedChoice);
+        if (!result.ok) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `[ERROR] ${result.message}`,
+                    },
+                ],
+            };
+        }
+        const output = [
+            `[${result.action}] ${result.message}`,
+            result.next_state ? `Next state: ${result.next_state}` : null,
+        ]
+            .filter(Boolean)
+            .join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: output,
+                },
+            ],
+        };
+    },
+};

package/build/mcp/cockpit-bridge/tools/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Cockpit MCP Tools
+ * Exports all cockpit.* tools for MCP registration
+ */
+export { cockpitStatusTool } from "./status.js";
+export { cockpitRunTool, cockpitStopTool, cockpitPauseTool, cockpitResumeTool, cockpitResetTool, } from "./command.js";
+export { cockpitDecideTool } from "./decide.js";
+export { cockpitPromptTool } from "./prompt.js";
+export { cockpitManualTool } from "./manual.js";
+/**
+ * All cockpit tools for registration
+ */
+export declare const cockpitTools: {
+    name: string;
+    module: string;
+    export: string;
+}[];

package/build/mcp/cockpit-bridge/tools/index.js

@@ -0,0 +1,28 @@
+/**
+ * Cockpit MCP Tools
+ * Exports all cockpit.* tools for MCP registration
+ */
+export { cockpitStatusTool } from "./status.js";
+export { cockpitRunTool, cockpitStopTool, cockpitPauseTool, cockpitResumeTool, cockpitResetTool, } from "./command.js";
+export { cockpitDecideTool } from "./decide.js";
+export { cockpitPromptTool } from "./prompt.js";
+export { cockpitManualTool } from "./manual.js";
+/**
+ * All cockpit tools for registration
+ */
+export const cockpitTools = [
+    // From status.ts
+    { name: "cockpit.status", module: "./status.js", export: "cockpitStatusTool" },
+    // From command.ts
+    { name: "cockpit.run", module: "./command.js", export: "cockpitRunTool" },
+    { name: "cockpit.stop", module: "./command.js", export: "cockpitStopTool" },
+    { name: "cockpit.pause", module: "./command.js", export: "cockpitPauseTool" },
+    { name: "cockpit.resume", module: "./command.js", export: "cockpitResumeTool" },
+    { name: "cockpit.reset", module: "./command.js", export: "cockpitResetTool" },
+    // From decide.ts
+    { name: "cockpit.decide", module: "./decide.js", export: "cockpitDecideTool" },
+    // From prompt.ts
+    { name: "cockpit.prompt", module: "./prompt.js", export: "cockpitPromptTool" },
+    // From manual.ts
+    { name: "cockpit.manual", module: "./manual.js", export: "cockpitManualTool" },
+];

package/build/mcp/cockpit-bridge/tools/manual.d.ts

@@ -0,0 +1,26 @@
+/**
+ * cockpit.manual MCP Tool
+ * Get embedded documentation
+ */
+export declare const cockpitManualTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            topic: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: {
+        topic: string;
+    }) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+};

package/build/mcp/cockpit-bridge/tools/manual.js

@@ -0,0 +1,56 @@
+/**
+ * cockpit.manual MCP Tool
+ * Get embedded documentation
+ */
+import { cockpitManual, isCockpitdAvailable } from "../client.js";
+export const cockpitManualTool = {
+    name: "cockpit.manual",
+    description: "Get embedded documentation from cockpitd (topics: work_failure, platform_failure, loop_rules, startup, commands)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            topic: {
+                type: "string",
+                description: "Documentation topic (work_failure, platform_failure, loop_rules, startup, commands)",
+            },
+        },
+        required: ["topic"],
+    },
+    handler: async (args) => {
+        if (!(await isCockpitdAvailable())) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "[OFFLINE] cockpitd is not running. Start it with: ./cockpitd",
+                    },
+                ],
+            };
+        }
+        const manual = await cockpitManual(args.topic);
+        if (!manual.found) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `[NOT_FOUND] ${manual.content}\n\nAvailable topics: ${manual.related_topics.join(", ")}`,
+                    },
+                ],
+            };
+        }
+        const output = [
+            manual.content,
+            "",
+            `---`,
+            `Related topics: ${manual.related_topics.join(", ")}`,
+        ].join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: output,
+                },
+            ],
+        };
+    },
+};

package/build/mcp/cockpit-bridge/tools/prompt.d.ts

@@ -0,0 +1,19 @@
+/**
+ * cockpit.prompt MCP Tool
+ * Get current pending prompt (if any)
+ */
+export declare const cockpitPromptTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+        required: never[];
+    };
+    handler: () => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+};

package/build/mcp/cockpit-bridge/tools/prompt.js

@@ -0,0 +1,57 @@
+/**
+ * cockpit.prompt MCP Tool
+ * Get current pending prompt (if any)
+ */
+import { cockpitPrompt, isCockpitdAvailable } from "../client.js";
+export const cockpitPromptTool = {
+    name: "cockpit.prompt",
+    description: "Get current pending prompt from cockpitd (if blocked)",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    handler: async () => {
+        if (!(await isCockpitdAvailable())) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "[OFFLINE] cockpitd is not running. Start it with: ./cockpitd",
+                    },
+                ],
+            };
+        }
+        const prompt = await cockpitPrompt();
+        if (!prompt.has_prompt) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "[NO_PROMPT] No pending prompt. Cockpitd is not blocked.",
+                    },
+                ],
+            };
+        }
+        // Format prompt with choices
+        const lines = [
+            `[${prompt.prompt_type}]`,
+            prompt.reason_code ? `Reason: ${prompt.reason_code}` : null,
+            "",
+            prompt.question,
+            "",
+            "Choices:",
+            ...prompt.choices.map((c) => `  ${c.id}: ${c.label}${c.description ? ` - ${c.description}` : ""}`),
+            "",
+            "Use cockpit.decide to submit your choice.",
+        ].filter((line) => line !== null);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: lines.join("\n"),
+                },
+            ],
+        };
+    },
+};

package/build/mcp/cockpit-bridge/tools/status.d.ts

@@ -0,0 +1,19 @@
+/**
+ * cockpit.status MCP Tool
+ * Returns one-line cockpit status
+ */
+export declare const cockpitStatusTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+        required: never[];
+    };
+    handler: () => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+};

package/build/mcp/cockpit-bridge/tools/status.js

@@ -0,0 +1,50 @@
+/**
+ * cockpit.status MCP Tool
+ * Returns one-line cockpit status
+ */
+import { cockpitStatus, isCockpitdAvailable } from "../client.js";
+export const cockpitStatusTool = {
+    name: "cockpit.status",
+    description: "Get current cockpit status (1-line dashboard)",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    handler: async () => {
+        // Check if cockpitd is available
+        if (!(await isCockpitdAvailable())) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "[OFFLINE] cockpitd is not running. Start it with: ./cockpitd",
+                    },
+                ],
+            };
+        }
+        const status = await cockpitStatus();
+        // Format one-line status
+        const parts = [
+            `[${status.state}]`,
+            `run=${status.run_id ?? "none"}`,
+        ];
+        if (status.phase) {
+            parts.push(`phase=${status.phase}`);
+        }
+        if (status.verdict) {
+            parts.push(`verdict=${status.verdict}`);
+        }
+        if (status.next_action) {
+            parts.push(`next=${status.next_action.id}`);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: parts.join(" "),
+                },
+            ],
+        };
+    },
+};