feedback-layer-mcp 0.1.0 → 0.1.1

package/README.md

@@ -16,8 +16,17 @@ The init command stores credentials in:
 ~/.config/feedback-layer/auth.json
 ```
 
-It also writes local MCP client configuration for Claude-style `.mcp.json` and
-Codex `~/.codex/config.toml`.
+It also writes the project binding for the current repo in:
+
+```txt
+.feedback-layer/project.json
+```
+
+That means the same token can be authorized for several projects, while each
+workspace still resolves to exactly one active project.
+
+Init also writes local MCP client configuration for Claude-style `.mcp.json`
+and Codex `~/.codex/config.toml`.
 
 ## Standard MCP Config
 
@@ -97,6 +106,7 @@ The short alias `fl-mcp` is also available.
 
 ## 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.
+Do not commit tokens. Prefer `init`, which stores the token in a user-local file
+with `0600` permissions. Task APIs are scoped to the active project resolved
+from `FL_PROJECT_SLUG`, `.feedback-layer/project.json`, or the local `.mcp.json`
+for the current workspace.

package/dist/cli/init.js

@@ -1,10 +1,10 @@
-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";
+import { detectRepoRemote, writeLocalProjectConfig } from "../config/project.js";
 function readFlagValue(args, index, flag) {
     const value = args[index + 1];
     if (!value || value.startsWith("--")) {
@@ -52,16 +52,6 @@ Options:
   -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) {
@@ -70,6 +60,7 @@ export async function runInit(args = []) {
     }
     const rl = createInterface({ input, output });
     const existing = await readAuthConfig();
+    const authConfig = { ...existing, projectSlug: undefined };
     const apiBaseUrl = flags.apiBaseUrl ||
         (await rl.question(`Feedback Layer URL (${existing.apiBaseUrl ?? DEFAULT_API_BASE_URL}): `)) ||
         existing.apiBaseUrl ||
@@ -79,12 +70,12 @@ export async function runInit(args = []) {
         existing.token;
     if (!token)
         throw new Error("Missing Feedback Layer MCP token");
-    await writeAuthConfig({ ...existing, apiBaseUrl, token });
+    await writeAuthConfig({ ...authConfig, apiBaseUrl, token });
+    const repoUrl = flags.repoUrl || (await detectRepoRemote());
     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 =
@@ -93,16 +84,13 @@ export async function runInit(args = []) {
                     throw new Error("No MCP-enabled project matched this token/repo");
                 })();
     }
-    await writeAuthConfig({
-        ...existing,
-        apiBaseUrl,
-        token,
-        projectSlug: project.slug,
-    });
+    await writeAuthConfig({ ...authConfig, apiBaseUrl, token });
+    await writeLocalProjectConfig({ projectSlug: project.slug, repoUrl });
     await writeClaudeConfig(project.slug);
-    await writeCodexConfig(project.slug);
+    await writeCodexConfig();
     rl.close();
     console.log(`Detected project: ${project.name} (${project.slug})`);
+    console.log("Wrote .feedback-layer/project.json");
     console.log("Wrote .mcp.json");
     console.log("Updated ~/.codex/config.toml");
 }

package/dist/client/api.js

@@ -1,7 +1,13 @@
 import { resolveRuntimeConfig } from "./auth.js";
+function isTaskEndpoint(pathname) {
+    return pathname === "/api/mcp/tasks" || pathname.startsWith("/api/mcp/tasks/");
+}
 export async function feedbackLayerApi(path, options = {}) {
     const config = await resolveRuntimeConfig();
     const url = new URL(path, config.apiBaseUrl);
+    if (config.projectSlug && isTaskEndpoint(url.pathname)) {
+        url.searchParams.set("project", config.projectSlug);
+    }
     const res = await fetch(url, {
         method: options.method ?? "GET",
         headers: {

package/dist/client/auth.js

@@ -1,6 +1,7 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { detectRepoRemote, normalizeRepoUrl, readLocalProjectConfig, } from "../config/project.js";
 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() {
@@ -18,11 +19,40 @@ export async function writeAuthConfig(config) {
         mode: 0o600,
     });
 }
+async function readProjectSlugFromMcpConfig() {
+    try {
+        const raw = await readFile(join(process.cwd(), ".mcp.json"), "utf8");
+        const config = JSON.parse(raw);
+        return config.mcpServers?.["feedback-layer"]?.env?.FL_PROJECT_SLUG;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolveProjectSlug() {
+    if (process.env.FL_PROJECT_SLUG)
+        return process.env.FL_PROJECT_SLUG;
+    let local = null;
+    try {
+        local = await readLocalProjectConfig();
+    }
+    catch { }
+    if (local?.repoUrl) {
+        const currentRepoUrl = await detectRepoRemote();
+        if (!currentRepoUrl ||
+            normalizeRepoUrl(currentRepoUrl) !== normalizeRepoUrl(local.repoUrl)) {
+            throw new Error("Feedback Layer project config does not match this git remote. Run `feedback-layer-mcp init` in this workspace.");
+        }
+    }
+    if (local?.projectSlug)
+        return local.projectSlug;
+    return await readProjectSlugFromMcpConfig();
+}
 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;
+    const projectSlug = await resolveProjectSlug();
     if (!token) {
         throw new Error("Missing Feedback Layer token. Run `feedback-layer-mcp init`.");
     }

package/dist/config/codex.d.ts

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

package/dist/config/codex.js

@@ -2,7 +2,7 @@ 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) {
+export async function writeCodexConfig() {
     let current = "";
     try {
         current = await readFile(CODEX_CONFIG, "utf8");
@@ -13,9 +13,6 @@ export async function writeCodexConfig(projectSlug) {
     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, "")

package/dist/config/project.d.ts

@@ -0,0 +1,10 @@
+export type LocalProjectConfig = {
+    projectSlug: string;
+    repoUrl?: string | null;
+};
+export declare const LOCAL_PROJECT_CONFIG: string;
+export declare function normalizeRepoUrl(value: string): string;
+export declare function findGitRoot(start?: string): Promise<string | null>;
+export declare function detectRepoRemote(start?: string): Promise<string | null>;
+export declare function readLocalProjectConfig(): Promise<LocalProjectConfig>;
+export declare function writeLocalProjectConfig(config: LocalProjectConfig): Promise<void>;

package/dist/config/project.js

@@ -0,0 +1,68 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, parse } from "node:path";
+const PROJECT_CONFIG_RELATIVE = join(".feedback-layer", "project.json");
+export const LOCAL_PROJECT_CONFIG = join(process.cwd(), PROJECT_CONFIG_RELATIVE);
+async function findUp(relativePath, start = process.cwd()) {
+    let current = start;
+    while (true) {
+        const candidate = join(current, relativePath);
+        try {
+            await readFile(candidate, "utf8");
+            return candidate;
+        }
+        catch { }
+        const parent = dirname(current);
+        if (parent === current || current === parse(current).root)
+            return null;
+        current = parent;
+    }
+}
+function parseOriginRemote(gitConfig) {
+    const match = gitConfig.match(/\[remote "origin"\][\s\S]*?url = (.+)/);
+    return match?.[1]?.trim() ?? null;
+}
+export function normalizeRepoUrl(value) {
+    return value
+        .trim()
+        .replace(/^git@([^:]+):(.+)$/, "https://$1/$2")
+        .replace(/\.git$/, "")
+        .toLowerCase();
+}
+export async function findGitRoot(start = process.cwd()) {
+    let current = start;
+    while (true) {
+        try {
+            await readFile(join(current, ".git", "config"), "utf8");
+            return current;
+        }
+        catch { }
+        const parent = dirname(current);
+        if (parent === current || current === parse(current).root)
+            return null;
+        current = parent;
+    }
+}
+export async function detectRepoRemote(start = process.cwd()) {
+    const gitRoot = await findGitRoot(start);
+    if (!gitRoot)
+        return null;
+    try {
+        return parseOriginRemote(await readFile(join(gitRoot, ".git", "config"), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export async function readLocalProjectConfig() {
+    const configPath = await findUp(PROJECT_CONFIG_RELATIVE);
+    if (!configPath)
+        throw new Error("Missing local Feedback Layer project config");
+    const raw = await readFile(configPath, "utf8");
+    return JSON.parse(raw);
+}
+export async function writeLocalProjectConfig(config) {
+    const gitRoot = await findGitRoot();
+    const configPath = join(gitRoot ?? process.cwd(), PROJECT_CONFIG_RELATIVE);
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`);
+}

package/dist/index.js

@@ -59,7 +59,7 @@ async function callTool(name, args) {
     throw new Error(`Unknown tool: ${name}`);
 }
 async function startServer() {
-    const server = new Server({ name: "feedback-layer", version: "0.1.0" }, { capabilities: { tools: {} } });
+    const server = new Server({ name: "feedback-layer", version: "0.1.1" }, { capabilities: { tools: {} } });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const result = await callTool(request.params.name, asRecord(request.params.arguments));

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

@@ -6,9 +6,24 @@ export declare const getTaskTool: {
         properties: {
             taskId: {
                 type: string;
+                description: string;
+            };
+            id: {
+                type: string;
+                description: string;
+            };
+            feedbackId: {
+                type: string;
+                description: string;
+            };
+            code: {
+                type: string;
+                description: string;
             };
         };
-        required: string[];
+        anyOf: {
+            required: string[];
+        }[];
     };
 };
 export declare function getTask(args: Record<string, unknown>): Promise<unknown>;

package/dist/tools/get-task.js

@@ -1,15 +1,39 @@
 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.",
+    description: "Get a Feedback Layer task by task id, feedback id, or visible feedback code, including the generated implementation prompt and acceptance criteria.",
     inputSchema: {
         type: "object",
         properties: {
-            taskId: { type: "string" },
+            taskId: {
+                type: "string",
+                description: "Generated task id returned by list_tasks.",
+            },
+            id: {
+                type: "string",
+                description: "Alias for taskId.",
+            },
+            feedbackId: {
+                type: "string",
+                description: "Feedback id returned by list_tasks.",
+            },
+            code: {
+                type: "string",
+                description: "Human-readable feedback code, for example FB-253.",
+            },
         },
-        required: ["taskId"],
+        anyOf: [
+            { required: ["taskId"] },
+            { required: ["id"] },
+            { required: ["feedbackId"] },
+            { required: ["code"] },
+        ],
     },
 };
 export async function getTask(args) {
-    return feedbackLayerApi(`/api/mcp/tasks/${String(args.taskId)}`);
+    const identifier = args.taskId ?? args.id ?? args.feedbackId ?? args.code;
+    if (typeof identifier !== "string" || identifier.trim().length === 0) {
+        throw new Error("Missing task identifier. Pass taskId, feedbackId, or code.");
+    }
+    return feedbackLayerApi(`/api/mcp/tasks/${encodeURIComponent(identifier.trim())}`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feedback-layer-mcp",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Feedback Layer MCP server for exposing selected feedback requests to coding agents.",
   "repository": {
     "type": "git",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/VentureIA/feedback-layer",
     "source": "github"
   },
-  "version": "0.1.0",
+  "version": "0.1.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "feedback-layer-mcp",
-      "version": "0.1.0",
+      "version": "0.1.1",
       "transport": {
         "type": "stdio"
       }