feedback-layer-mcp 0.1.0

package/README.md

@@ -0,0 +1,102 @@
+# Feedback Layer MCP
+
+Feedback Layer MCP exposes selected project feedback requests to coding agents.
+It runs as a local stdio MCP server and talks to your Feedback Layer API over
+HTTPS with a personal access token.
+
+## Quick Start
+
+```bash
+npx -y feedback-layer-mcp@latest init
+```
+
+The init command stores credentials in:
+
+```txt
+~/.config/feedback-layer/auth.json
+```
+
+It also writes local MCP client configuration for Claude-style `.mcp.json` and
+Codex `~/.codex/config.toml`.
+
+## Standard MCP Config
+
+```json
+{
+  "mcpServers": {
+    "feedback-layer": {
+      "command": "npx",
+      "args": ["-y", "feedback-layer-mcp@latest"]
+    }
+  }
+}
+```
+
+## Codex
+
+```bash
+codex mcp add feedback-layer npx "feedback-layer-mcp@latest"
+npx -y feedback-layer-mcp@latest init
+```
+
+Or edit `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.feedback-layer]
+command = "npx"
+args = ["-y", "feedback-layer-mcp@latest"]
+```
+
+## Claude Code
+
+```bash
+claude mcp add feedback-layer npx feedback-layer-mcp@latest
+npx -y feedback-layer-mcp@latest init
+```
+
+## Cursor, Windsurf, VS Code and Other Clients
+
+Use the standard MCP config above. Feedback Layer uses stdio transport, so the
+client starts the package locally with `npx`.
+
+## Non-Interactive Setup
+
+```bash
+npx -y feedback-layer-mcp@latest init \
+  --url https://feedback-layer.venture-ia.com \
+  --token flp_live_xxx \
+  --project findy
+```
+
+Environment-only configuration also works:
+
+```bash
+FL_API_BASE_URL=https://feedback-layer.venture-ia.com \
+FL_PROJECT_SLUG=findy \
+FL_TOKEN=flp_live_xxx \
+npx -y feedback-layer-mcp@latest
+```
+
+## Commands
+
+```bash
+feedback-layer-mcp init
+feedback-layer-mcp doctor
+feedback-layer-mcp status
+```
+
+The short alias `fl-mcp` is also available.
+
+## Tools
+
+- `list_tasks` - list ready tasks for the configured project
+- `get_task` - read one task with implementation prompt and acceptance criteria
+- `claim_task` - claim a task for the current local session
+- `complete_task` - mark a claimed task complete with a PR URL
+- `release_task` - release a claimed task back to the ready queue
+
+## Security
+
+Do not commit tokens or generated client config. Keep `.mcp.json` local when it
+contains environment secrets. Prefer `init`, which stores the token in a
+user-local file with `0600` permissions.

package/dist/cli/init.d.ts

@@ -0,0 +1,10 @@
+type InitFlags = {
+    apiBaseUrl?: string;
+    token?: string;
+    projectSlug?: string;
+    repoUrl?: string;
+    help?: boolean;
+};
+export declare function parseInitFlags(args: string[]): InitFlags;
+export declare function runInit(args?: string[]): Promise<void>;
+export {};

package/dist/cli/init.js

@@ -0,0 +1,108 @@
+import { readFile } from "node:fs/promises";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { feedbackLayerApi } from "../client/api.js";
+import { DEFAULT_API_BASE_URL, readAuthConfig, writeAuthConfig, } from "../client/auth.js";
+import { writeClaudeConfig } from "../config/claude-code.js";
+import { writeCodexConfig } from "../config/codex.js";
+function readFlagValue(args, index, flag) {
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+        throw new Error(`Missing value for ${flag}`);
+    }
+    return value;
+}
+export function parseInitFlags(args) {
+    const flags = {};
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            flags.help = true;
+        }
+        else if (arg === "--url" || arg === "--api-base-url") {
+            flags.apiBaseUrl = readFlagValue(args, i, arg);
+            i += 1;
+        }
+        else if (arg === "--token") {
+            flags.token = readFlagValue(args, i, arg);
+            i += 1;
+        }
+        else if (arg === "--project" || arg === "--project-slug") {
+            flags.projectSlug = readFlagValue(args, i, arg);
+            i += 1;
+        }
+        else if (arg === "--repo-url") {
+            flags.repoUrl = readFlagValue(args, i, arg);
+            i += 1;
+        }
+        else {
+            throw new Error(`Unknown init option: ${arg}`);
+        }
+    }
+    return flags;
+}
+function printInitHelp() {
+    console.log(`Usage: feedback-layer-mcp init [options]
+
+Options:
+  --url <url>          Feedback Layer URL. Defaults to ${DEFAULT_API_BASE_URL}
+  --token <token>      Feedback Layer MCP token
+  --project <slug>     Project slug, for example findy
+  --repo-url <url>     Repository URL used for project auto-detection
+  -h, --help           Show this help
+`);
+}
+async function detectRepoRemote() {
+    try {
+        const gitConfig = await readFile(".git/config", "utf8");
+        const match = gitConfig.match(/\[remote "origin"\][\s\S]*?url = (.+)/);
+        return match?.[1]?.trim() ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function runInit(args = []) {
+    const flags = parseInitFlags(args);
+    if (flags.help) {
+        printInitHelp();
+        return;
+    }
+    const rl = createInterface({ input, output });
+    const existing = await readAuthConfig();
+    const apiBaseUrl = flags.apiBaseUrl ||
+        (await rl.question(`Feedback Layer URL (${existing.apiBaseUrl ?? DEFAULT_API_BASE_URL}): `)) ||
+        existing.apiBaseUrl ||
+        DEFAULT_API_BASE_URL;
+    const token = flags.token ||
+        (await rl.question("Paste Feedback Layer MCP token: ")) ||
+        existing.token;
+    if (!token)
+        throw new Error("Missing Feedback Layer MCP token");
+    await writeAuthConfig({ ...existing, apiBaseUrl, token });
+    let project = flags.projectSlug
+        ? { slug: flags.projectSlug, name: flags.projectSlug }
+        : null;
+    if (!project) {
+        const repoUrl = flags.repoUrl || (await detectRepoRemote());
+        const qs = repoUrl ? `?repoUrl=${encodeURIComponent(repoUrl)}` : "";
+        const detected = await feedbackLayerApi(`/api/mcp/projects${qs}`);
+        project =
+            detected.projects[0] ??
+                (() => {
+                    throw new Error("No MCP-enabled project matched this token/repo");
+                })();
+    }
+    await writeAuthConfig({
+        ...existing,
+        apiBaseUrl,
+        token,
+        projectSlug: project.slug,
+    });
+    await writeClaudeConfig(project.slug);
+    await writeCodexConfig(project.slug);
+    rl.close();
+    console.log(`Detected project: ${project.name} (${project.slug})`);
+    console.log("Wrote .mcp.json");
+    console.log("Updated ~/.codex/config.toml");
+}

package/dist/cli/status.d.ts

@@ -0,0 +1,2 @@
+export declare function runStatus(): Promise<void>;
+export declare function runDoctor(): Promise<void>;

package/dist/cli/status.js

@@ -0,0 +1,14 @@
+import { feedbackLayerApi } from "../client/api.js";
+import { resolveProjectRuntimeConfig } from "../client/auth.js";
+export async function runStatus() {
+    const config = await resolveProjectRuntimeConfig();
+    const result = await feedbackLayerApi(`/api/mcp/tasks?project=${encodeURIComponent(config.projectSlug)}&limit=5`);
+    console.log(JSON.stringify({ config: { ...config, token: "[redacted]" }, result }, null, 2));
+}
+export async function runDoctor() {
+    const config = await resolveProjectRuntimeConfig();
+    await feedbackLayerApi(`/api/mcp/tasks?project=${encodeURIComponent(config.projectSlug)}&limit=1`);
+    console.log("Feedback Layer MCP doctor: ok");
+    console.log(`API: ${config.apiBaseUrl}`);
+    console.log(`Project: ${config.projectSlug}`);
+}

package/dist/client/api.d.ts

@@ -0,0 +1,6 @@
+type ApiOptions = {
+    method?: "GET" | "POST";
+    body?: unknown;
+};
+export declare function feedbackLayerApi<T>(path: string, options?: ApiOptions): Promise<T>;
+export {};

package/dist/client/api.js

@@ -0,0 +1,24 @@
+import { resolveRuntimeConfig } from "./auth.js";
+export async function feedbackLayerApi(path, options = {}) {
+    const config = await resolveRuntimeConfig();
+    const url = new URL(path, config.apiBaseUrl);
+    const res = await fetch(url, {
+        method: options.method ?? "GET",
+        headers: {
+            Authorization: `Bearer ${config.token}`,
+            "Content-Type": "application/json",
+        },
+        body: options.body === undefined ? undefined : JSON.stringify(options.body),
+    });
+    const text = await res.text();
+    const data = text ? JSON.parse(text) : {};
+    if (!res.ok) {
+        const message = typeof data?.message === "string"
+            ? data.message
+            : typeof data?.error === "string"
+                ? data.error
+                : `Feedback Layer API ${res.status}`;
+        throw new Error(message);
+    }
+    return data;
+}

package/dist/client/auth.d.ts

@@ -0,0 +1,20 @@
+type AuthConfig = {
+    token?: string;
+    apiBaseUrl?: string;
+    projectSlug?: string;
+};
+export declare const DEFAULT_API_BASE_URL = "https://feedback-layer.venture-ia.com";
+export declare const AUTH_PATH: string;
+export declare function readAuthConfig(): Promise<AuthConfig>;
+export declare function writeAuthConfig(config: AuthConfig): Promise<void>;
+export declare function resolveRuntimeConfig(): Promise<{
+    token: string;
+    apiBaseUrl: string;
+    projectSlug: string | undefined;
+}>;
+export declare function resolveProjectRuntimeConfig(): Promise<{
+    projectSlug: string;
+    token: string;
+    apiBaseUrl: string;
+}>;
+export {};

package/dist/client/auth.js

@@ -0,0 +1,37 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export const DEFAULT_API_BASE_URL = "https://feedback-layer.venture-ia.com";
+export const AUTH_PATH = join(homedir(), ".config", "feedback-layer", "auth.json");
+export async function readAuthConfig() {
+    try {
+        const raw = await readFile(AUTH_PATH, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export async function writeAuthConfig(config) {
+    await mkdir(dirname(AUTH_PATH), { recursive: true });
+    await writeFile(AUTH_PATH, `${JSON.stringify(config, null, 2)}\n`, {
+        mode: 0o600,
+    });
+}
+export async function resolveRuntimeConfig() {
+    const file = await readAuthConfig();
+    const token = process.env.FL_TOKEN ?? file.token;
+    const apiBaseUrl = process.env.FL_API_BASE_URL ?? file.apiBaseUrl ?? DEFAULT_API_BASE_URL;
+    const projectSlug = process.env.FL_PROJECT_SLUG ?? file.projectSlug;
+    if (!token) {
+        throw new Error("Missing Feedback Layer token. Run `feedback-layer-mcp init`.");
+    }
+    return { token, apiBaseUrl, projectSlug };
+}
+export async function resolveProjectRuntimeConfig() {
+    const config = await resolveRuntimeConfig();
+    if (!config.projectSlug) {
+        throw new Error("Missing project slug. Set FL_PROJECT_SLUG or run init.");
+    }
+    return { ...config, projectSlug: config.projectSlug };
+}

package/dist/config/claude-code.d.ts

@@ -0,0 +1 @@
+export declare function writeClaudeConfig(projectSlug: string): Promise<void>;

package/dist/config/claude-code.js

@@ -0,0 +1,15 @@
+import { writeFile } from "node:fs/promises";
+export async function writeClaudeConfig(projectSlug) {
+    const config = {
+        mcpServers: {
+            "feedback-layer": {
+                command: "npx",
+                args: ["-y", "feedback-layer-mcp@latest"],
+                env: {
+                    FL_PROJECT_SLUG: projectSlug,
+                },
+            },
+        },
+    };
+    await writeFile(".mcp.json", `${JSON.stringify(config, null, 2)}\n`);
+}

package/dist/config/codex.d.ts

@@ -0,0 +1 @@
+export declare function writeCodexConfig(projectSlug: string): Promise<void>;

package/dist/config/codex.js

@@ -0,0 +1,26 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const CODEX_CONFIG = join(homedir(), ".codex", "config.toml");
+export async function writeCodexConfig(projectSlug) {
+    let current = "";
+    try {
+        current = await readFile(CODEX_CONFIG, "utf8");
+    }
+    catch {
+        current = "";
+    }
+    const block = `[mcp_servers.feedback-layer]
+command = "npx"
+args = ["-y", "feedback-layer-mcp@latest"]
+
+[mcp_servers.feedback-layer.env]
+FL_PROJECT_SLUG = "${projectSlug}"
+`;
+    const withoutExisting = current
+        .replace(/\n?\[mcp_servers\.feedback-layer\][\s\S]*?(?=\n\[|\s*$)/g, "")
+        .replace(/\n?\[mcp_servers\.feedback-layer\.env\][\s\S]*?(?=\n\[|\s*$)/g, "");
+    await mkdir(dirname(CODEX_CONFIG), { recursive: true });
+    const nextConfig = `${withoutExisting.trimEnd()}\n\n${block}`.trimStart();
+    await writeFile(CODEX_CONFIG, `${nextConfig}\n`);
+}

package/dist/heartbeat.d.ts

@@ -0,0 +1,3 @@
+export declare function startHeartbeat(taskId: string, sessionId: string): void;
+export declare function stopHeartbeat(taskId: string): void;
+export declare function releaseActiveClaims(sessionId: string): Promise<void>;

package/dist/heartbeat.js

@@ -0,0 +1,33 @@
+import { feedbackLayerApi } from "./client/api.js";
+const activeClaims = new Map();
+export function startHeartbeat(taskId, sessionId) {
+    stopHeartbeat(taskId);
+    const timer = setInterval(async () => {
+        try {
+            await feedbackLayerApi(`/api/mcp/tasks/${taskId}/heartbeat`, {
+                method: "POST",
+                body: { sessionId },
+            });
+        }
+        catch (err) {
+            console.error(`[feedback-layer] heartbeat failed for ${taskId}`, err);
+            stopHeartbeat(taskId);
+        }
+    }, 60_000);
+    activeClaims.set(taskId, timer);
+}
+export function stopHeartbeat(taskId) {
+    const timer = activeClaims.get(taskId);
+    if (timer)
+        clearInterval(timer);
+    activeClaims.delete(taskId);
+}
+export async function releaseActiveClaims(sessionId) {
+    for (const taskId of activeClaims.keys()) {
+        stopHeartbeat(taskId);
+        await feedbackLayerApi(`/api/mcp/tasks/${taskId}/release`, {
+            method: "POST",
+            body: { sessionId },
+        }).catch(() => { });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import crypto from "node:crypto";
+import os from "node:os";
+import process from "node:process";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { resolveProjectRuntimeConfig } from "./client/auth.js";
+import { releaseActiveClaims, startHeartbeat, stopHeartbeat } from "./heartbeat.js";
+import { runInit } from "./cli/init.js";
+import { runDoctor, runStatus } from "./cli/status.js";
+import { claimTask, claimTaskTool } from "./tools/claim-task.js";
+import { completeTask, completeTaskTool } from "./tools/complete-task.js";
+import { getTask, getTaskTool } from "./tools/get-task.js";
+import { listTasks, listTasksTool } from "./tools/list-tasks.js";
+import { releaseTask, releaseTaskTool } from "./tools/release-task.js";
+const sessionId = process.env.FL_SESSION_ID ??
+    crypto
+        .createHash("sha256")
+        .update(`${process.cwd()}|${os.hostname()}|${process.pid}`)
+        .digest("hex")
+        .slice(0, 24);
+const tools = [
+    listTasksTool,
+    getTaskTool,
+    claimTaskTool,
+    completeTaskTool,
+    releaseTaskTool,
+];
+function asRecord(value) {
+    return value && typeof value === "object"
+        ? value
+        : {};
+}
+async function callTool(name, args) {
+    const config = await resolveProjectRuntimeConfig();
+    if (name === "list_tasks")
+        return listTasks(args, config.projectSlug);
+    if (name === "get_task")
+        return getTask(args);
+    if (name === "claim_task") {
+        const result = await claimTask(args, sessionId);
+        if (typeof args.taskId === "string")
+            startHeartbeat(args.taskId, sessionId);
+        return result;
+    }
+    if (name === "complete_task") {
+        const result = await completeTask(args, sessionId);
+        if (typeof args.taskId === "string")
+            stopHeartbeat(args.taskId);
+        return result;
+    }
+    if (name === "release_task") {
+        const result = await releaseTask(args, sessionId);
+        if (typeof args.taskId === "string")
+            stopHeartbeat(args.taskId);
+        return result;
+    }
+    throw new Error(`Unknown tool: ${name}`);
+}
+async function startServer() {
+    const server = new Server({ name: "feedback-layer", version: "0.1.0" }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const result = await callTool(request.params.name, asRecord(request.params.arguments));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+async function main() {
+    const command = process.argv[2];
+    if (command === "init")
+        return runInit(process.argv.slice(3));
+    if (command === "status")
+        return runStatus();
+    if (command === "doctor")
+        return runDoctor();
+    if (command === "--help" || command === "-h") {
+        console.log(`Usage: feedback-layer-mcp [command]
+
+Commands:
+  init      Configure local auth and MCP client files
+  doctor    Verify API connectivity for the configured project
+  status    Print the current configuration and first tasks
+
+Run without a command to start the MCP stdio server.
+`);
+        return;
+    }
+    return startServer();
+}
+process.on("SIGINT", () => {
+    releaseActiveClaims(sessionId).finally(() => process.exit(0));
+});
+process.on("SIGTERM", () => {
+    releaseActiveClaims(sessionId).finally(() => process.exit(0));
+});
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/tools/claim-task.d.ts

@@ -0,0 +1,14 @@
+export declare const claimTaskTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            taskId: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function claimTask(args: Record<string, unknown>, sessionId: string): Promise<unknown>;

package/dist/tools/claim-task.js

@@ -0,0 +1,18 @@
+import { feedbackLayerApi } from "../client/api.js";
+export const claimTaskTool = {
+    name: "claim_task",
+    description: "Claim a task for this local session. The server locks it for 5 minutes; the MCP server heartbeats while active.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            taskId: { type: "string" },
+        },
+        required: ["taskId"],
+    },
+};
+export async function claimTask(args, sessionId) {
+    return feedbackLayerApi(`/api/mcp/tasks/${String(args.taskId)}/claim`, {
+        method: "POST",
+        body: { sessionId },
+    });
+}

package/dist/tools/complete-task.d.ts

@@ -0,0 +1,17 @@
+export declare const completeTaskTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            taskId: {
+                type: string;
+            };
+            prUrl: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function completeTask(args: Record<string, unknown>, sessionId: string): Promise<unknown>;

package/dist/tools/complete-task.js

@@ -0,0 +1,19 @@
+import { feedbackLayerApi } from "../client/api.js";
+export const completeTaskTool = {
+    name: "complete_task",
+    description: "Mark the claimed task complete for review. Requires a PR URL and moves the task to `en_review`.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            taskId: { type: "string" },
+            prUrl: { type: "string" },
+        },
+        required: ["taskId", "prUrl"],
+    },
+};
+export async function completeTask(args, sessionId) {
+    return feedbackLayerApi(`/api/mcp/tasks/${String(args.taskId)}/complete`, {
+        method: "POST",
+        body: { sessionId, prUrl: String(args.prUrl) },
+    });
+}

package/dist/tools/get-task.d.ts

@@ -0,0 +1,14 @@
+export declare const getTaskTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            taskId: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function getTask(args: Record<string, unknown>): Promise<unknown>;

package/dist/tools/get-task.js

@@ -0,0 +1,15 @@
+import { feedbackLayerApi } from "../client/api.js";
+export const getTaskTool = {
+    name: "get_task",
+    description: "Get a Feedback Layer task by id, including the generated implementation prompt and acceptance criteria.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            taskId: { type: "string" },
+        },
+        required: ["taskId"],
+    },
+};
+export async function getTask(args) {
+    return feedbackLayerApi(`/api/mcp/tasks/${String(args.taskId)}`);
+}

package/dist/tools/list-tasks.d.ts

@@ -0,0 +1,19 @@
+export declare const listTasksTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            limit: {
+                type: string;
+                default: number;
+                maximum: number;
+            };
+            minConfidence: {
+                type: string;
+                default: number;
+            };
+        };
+    };
+};
+export declare function listTasks(args: Record<string, unknown>, projectSlug: string): Promise<unknown>;

package/dist/tools/list-tasks.js

@@ -0,0 +1,22 @@
+import { feedbackLayerApi } from "../client/api.js";
+export const listTasksTool = {
+    name: "list_tasks",
+    description: "List ready Feedback Layer tasks for the configured project. Returns unclaimed `pret_ia` tasks sorted by priority.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            limit: { type: "integer", default: 10, maximum: 50 },
+            minConfidence: { type: "number", default: 0.5 },
+        },
+    },
+};
+export async function listTasks(args, projectSlug) {
+    const limit = Number(args.limit ?? 10);
+    const minConfidence = Number(args.minConfidence ?? 0.5);
+    const qs = new URLSearchParams({
+        project: projectSlug,
+        limit: String(limit),
+        minConfidence: String(minConfidence),
+    });
+    return feedbackLayerApi(`/api/mcp/tasks?${qs.toString()}`);
+}

package/dist/tools/release-task.d.ts

@@ -0,0 +1,14 @@
+export declare const releaseTaskTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            taskId: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function releaseTask(args: Record<string, unknown>, sessionId: string): Promise<unknown>;

package/dist/tools/release-task.js

@@ -0,0 +1,18 @@
+import { feedbackLayerApi } from "../client/api.js";
+export const releaseTaskTool = {
+    name: "release_task",
+    description: "Release the current claim for a task and return it to the ready queue if it is still MCP-owned.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            taskId: { type: "string" },
+        },
+        required: ["taskId"],
+    },
+};
+export async function releaseTask(args, sessionId) {
+    return feedbackLayerApi(`/api/mcp/tasks/${String(args.taskId)}/release`, {
+        method: "POST",
+        body: { sessionId },
+    });
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "feedback-layer-mcp",
+  "version": "0.1.0",
+  "description": "Feedback Layer MCP server for exposing selected feedback requests to coding agents.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VentureIA/feedback-layer.git",
+    "directory": "packages/mcp"
+  },
+  "homepage": "https://github.com/VentureIA/feedback-layer#readme",
+  "bugs": {
+    "url": "https://github.com/VentureIA/feedback-layer/issues"
+  },
+  "license": "UNLICENSED",
+  "mcpName": "io.github.ventureia/feedback-layer-mcp",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "feedback-layer-mcp": "dist/index.js",
+    "fl-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "server.json",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "doctor": "node dist/index.js doctor",
+    "prepack": "npm run build",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "devDependencies": {
+    "tsx": "^4.19.2",
+    "typescript": "^5"
+  }
+}

package/server.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.ventureia/feedback-layer-mcp",
+  "description": "Feedback Layer MCP server for exposing selected feedback requests to coding agents.",
+  "repository": {
+    "url": "https://github.com/VentureIA/feedback-layer",
+    "source": "github"
+  },
+  "version": "0.1.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "feedback-layer-mcp",
+      "version": "0.1.0",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}