frinus-mcp 3.5.0 → 3.6.0

package/dist/client/cp-client.d.ts

@@ -17,4 +17,7 @@ export declare class CpClient implements CpClientInterface {
     getCredential(integrationRef: string): Promise<any>;
     listCredentials(): Promise<any>;
     deleteCredential(integrationRef: string): Promise<void>;
+    listCredentialShares(integrationRef: string): Promise<any>;
+    shareCredential(integrationRef: string, userIdOrEmail: string): Promise<any>;
+    revokeCredentialShare(integrationRef: string, granteeUserId: string): Promise<void>;
 }

package/dist/client/cp-client.js

@@ -57,4 +57,20 @@ export class CpClient {
     async deleteCredential(integrationRef) {
         await this.client.delete(`/api/v1/credentials/${integrationRef}`);
     }
+    async listCredentialShares(integrationRef) {
+        const response = await this.client.get(`/api/v1/credentials/${integrationRef}/shares`);
+        return response.data;
+    }
+    async shareCredential(integrationRef, userIdOrEmail) {
+        // The API accepts either field; pick by shape so callers can pass
+        // whichever they have. An email is what a human or agent usually knows.
+        const body = userIdOrEmail.includes("@")
+            ? { email: userIdOrEmail }
+            : { user_id: userIdOrEmail };
+        const response = await this.client.post(`/api/v1/credentials/${integrationRef}/shares`, body);
+        return response.data;
+    }
+    async revokeCredentialShare(integrationRef, granteeUserId) {
+        await this.client.delete(`/api/v1/credentials/${integrationRef}/shares/${granteeUserId}`);
+    }
 }

package/dist/index.js

@@ -64,7 +64,7 @@ async function main() {
     }
     const server = new Server({
         name: "frinus",
-        version: "3.5.0",
+        version: "3.6.0",
     }, {
         capabilities: {
             tools: {},

package/dist/tools/definitions.js

@@ -1654,10 +1654,14 @@ RULES:
     },
     {
         name: "credential_list",
-        description: `List all stored credentials for the current user.
+        description: `List every credential you can access in this organization.
 
-Returns credential metadata (ref, type, created_at) without any secret data.
-Use this to see what integrations have stored credentials.`,
+Covers credentials you OWN and credentials other members SHARED with you.
+Each entry says which it is: shared ones are marked with who shared them,
+and owned ones with how many people they reach.
+
+Returns metadata only (ref, created_at, sharing info) — never secret data.
+Use a listed ref with 'credential_exec' to actually use the credential.`,
         inputSchema: {
             type: "object",
             properties: {},
@@ -1680,4 +1684,85 @@ This cannot be undone.`,
             required: ["ref"],
         },
     },
+    {
+        name: "credential_share",
+        description: `Share a credential you own with another member of your organization.
+
+The grant gives that member the SAME access you have: they can run
+'credential_exec' with the ref and read the value. There is no reduced
+"use but never reveal" level, and that is deliberate — 'credential_exec'
+takes an arbitrary argv, so any such tier would be one command away from
+being bypassed. Share only with people you would hand the secret to.
+
+What stays yours alone is MANAGEMENT: only the owner can share, revoke,
+overwrite or delete a credential. Receiving a share never confers that.
+
+Identify the recipient by 'email' (usual) or 'user_id' (Keycloak UUID).
+They must already be an active member of your organization.
+
+Idempotent: re-sharing with the same person is a no-op, not an error.
+
+Revoking later stops FUTURE access — it cannot un-read what was already
+read. If a secret may have been misused, rotate it.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                ref: {
+                    type: "string",
+                    description: "Credential reference you own (e.g., 'mysql_prod', 'jira_muza')",
+                },
+                email: {
+                    type: "string",
+                    description: "Email of the org member who will receive access",
+                },
+                user_id: {
+                    type: "string",
+                    description: "Keycloak UUID of the member (alternative to email)",
+                },
+            },
+            required: ["ref"],
+        },
+    },
+    {
+        name: "credential_unshare",
+        description: `Revoke a member's access to a credential you own.
+
+Stops future access only. It does NOT undo what the person already read:
+if you are revoking because the secret may have leaked, rotate the secret
+as well — revocation is not a recall.
+
+Owner-only.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                ref: {
+                    type: "string",
+                    description: "Credential reference you own",
+                },
+                user_id: {
+                    type: "string",
+                    description: "Keycloak UUID of the member whose access is revoked",
+                },
+            },
+            required: ["ref", "user_id"],
+        },
+    },
+    {
+        name: "credential_shares",
+        description: `List who a credential you own is shared with.
+
+Owner-only: holding a share does not let you see the other recipients.
+Returns each grantee (email/name when the directory resolves them), who
+granted it and when. No secret data.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                ref: {
+                    type: "string",
+                    description: "Credential reference you own",
+                },
+            },
+            required: ["ref"],
+        },
+    },
 ];

package/dist/tools/handlers.js

@@ -2027,11 +2027,22 @@ const handlers = {
                         }],
                 };
             }
-            const lines = items.map((c) => `- ${c.integration_type} (created: ${c.created_at})`);
+            // Mark provenance: owned vs shared-with-me. An agent picking a ref
+            // should know whether it may manage it (share/revoke/delete) or only
+            // use it — management is owner-only server-side.
+            const lines = items.map((c) => {
+                if (c.is_owner === false) {
+                    return `- ${c.integration_type} (shared with you; owner manages it)`;
+                }
+                const shared = c.share_count > 0
+                    ? `, shared with ${c.share_count} member${c.share_count === 1 ? "" : "s"}`
+                    : "";
+                return `- ${c.integration_type} (yours, created: ${c.created_at}${shared})`;
+            });
             return {
                 content: [{
                         type: "text",
-                        text: `Stored credentials (${items.length}):\n${lines.join("\n")}`,
+                        text: `Credentials you can access (${items.length}):\n${lines.join("\n")}\n\nUse a ref with credential_exec to run a command with it injected.`,
                     }],
             };
         }
@@ -2068,6 +2079,126 @@ const handlers = {
             throw error;
         }
     },
+    // --- Sharing -------------------------------------------------------------
+    // A share conveys the owner's full access (use + read). No reduced tier
+    // exists on purpose: credential_exec takes an arbitrary argv, so a
+    // "use but never reveal" level would be bypassable and would only give
+    // false assurance. Management stays owner-only, enforced server-side.
+    async credential_share(args, { cpClient }) {
+        const ref = args.ref;
+        const email = args.email;
+        const userId = args.user_id;
+        if (!email && !userId) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "Provide either 'email' or 'user_id' of the org member to share with.",
+                    }],
+                isError: true,
+            };
+        }
+        if (email && userId) {
+            return {
+                content: [{ type: "text", text: "Provide either 'email' or 'user_id', not both." }],
+                isError: true,
+            };
+        }
+        try {
+            const share = await cpClient.shareCredential(ref, (userId ?? email));
+            const who = share?.email || share?.name || share?.grantee_user_id || email || userId;
+            return {
+                content: [{
+                        type: "text",
+                        text: `Credential '${ref}' is now shared with ${who}.\n` +
+                            "They have the same access you do: they can use it and read its value.\n" +
+                            "You remain the only one who can share, revoke, overwrite or delete it.\n" +
+                            "Revoking later stops future access but cannot un-read what was already read — rotate the secret if it may leak.",
+                    }],
+            };
+        }
+        catch (error) {
+            const status = error?.response?.status;
+            const detail = error?.response?.data?.detail;
+            if (status === 404 || status === 400) {
+                return {
+                    content: [{ type: "text", text: detail || `Could not share '${ref}'.` }],
+                    isError: true,
+                };
+            }
+            const apiErr = handleApiError(error);
+            if (apiErr)
+                return apiErr;
+            throw error;
+        }
+    },
+    async credential_unshare(args, { cpClient }) {
+        const ref = args.ref;
+        const userId = args.user_id;
+        try {
+            await cpClient.revokeCredentialShare(ref, userId);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Access to '${ref}' revoked for ${userId}.\n` +
+                            "This stops FUTURE access only. If the secret may have been read and misused, rotate it.",
+                    }],
+            };
+        }
+        catch (error) {
+            if (error?.response?.status === 404) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: error?.response?.data?.detail || `No share found for '${ref}' and that user.`,
+                        }],
+                    isError: true,
+                };
+            }
+            const apiErr = handleApiError(error);
+            if (apiErr)
+                return apiErr;
+            throw error;
+        }
+    },
+    async credential_shares(args, { cpClient }) {
+        const ref = args.ref;
+        try {
+            const result = await cpClient.listCredentialShares(ref);
+            const items = result?.items || [];
+            if (items.length === 0) {
+                return {
+                    content: [{ type: "text", text: `Credential '${ref}' is not shared with anyone.` }],
+                };
+            }
+            const lines = items.map((sh) => {
+                const who = sh.email || sh.name || sh.grantee_user_id;
+                return `- ${who} (user_id: ${sh.grantee_user_id}, since ${sh.granted_at})`;
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `'${ref}' is shared with ${items.length} member${items.length === 1 ? "" : "s"}:\n` +
+                            lines.join("\n") +
+                            "\n\nEach of them has the same access you do. Use credential_unshare(ref, user_id) to revoke.",
+                    }],
+            };
+        }
+        catch (error) {
+            if (error?.response?.status === 404) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: error?.response?.data?.detail || `You do not own a credential named '${ref}'`,
+                        }],
+                    isError: true,
+                };
+            }
+            const apiErr = handleApiError(error);
+            if (apiErr)
+                return apiErr;
+            throw error;
+        }
+    },
 };
 // ---------------------------------------------------------------------------
 // Dispatcher: looks up the handler and executes it with error handling

package/dist/types/index.d.ts

@@ -75,6 +75,9 @@ export interface CpClientInterface {
     getCredential(integrationRef: string): Promise<any>;
     listCredentials(): Promise<any>;
     deleteCredential(integrationRef: string): Promise<void>;
+    listCredentialShares(integrationRef: string): Promise<any>;
+    shareCredential(integrationRef: string, userIdOrEmail: string): Promise<any>;
+    revokeCredentialShare(integrationRef: string, granteeUserId: string): Promise<void>;
 }
 /** Public surface of the MemoryClient used by handlers. */
 export interface MemoryClientInterface {

package/manifest.json

@@ -2,8 +2,8 @@
   "manifest_version": "0.3",
   "name": "frinus",
   "display_name": "Frinus — Memória Cognitiva",
-  "version": "3.5.0",
-  "description": "Memória cognitiva de longo prazo para o Claude (φρήν + νοῦς). 80 ferramentas de memória, sessões, agentes e conhecimento.",
+  "version": "3.6.0",
+  "description": "Memória cognitiva de longo prazo para o Claude (φρήν + νοῦς). 83 ferramentas de memória, sessões, agentes e conhecimento.",
   "long_description": "O Frinus dá ao Claude memória de longo prazo, identidade e inteligência persistente entre conversas. Conecta o Claude Desktop à plataforma Frinus (Memory Engine, Control Plane e Agent Service) via MCP. Basta colar sua chave de API pessoal — nada para instalar ou compilar.",
   "author": {
     "name": "Frinus",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frinus-mcp",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "Frinus - MCP Server for Cognitive Memory (φρήν + νοῦς). Long-term memory, sessions, agents and knowledge for Claude and any MCP client.",
   "type": "module",
   "main": "dist/index.js",