@sassoftware/sas-score-mcp-serverjs 0.4.1-7 → 1.0.0

package/src/expressMcpServer.js

@@ -11,21 +11,22 @@ import selfsigned from "selfsigned";
 import openAPIJson from "./openAPIJson.js";
 
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { randomUUID, randomBytes, createHash } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
-import { Agent, fetch as undiciFetch } from "undici";
+
 import tlogon from "./toolHelpers/tlogon.js";
 
+import { getMetadata, authorize, callback, token, baseUrl } from "./oauthHandlers/index.js";
+import processHeaders from "./processHeaders.js";
 
 // setup express server
 
 async function expressMcpServer(mcpServer, cache, baseAppEnvContext) {
   // setup for change to persistence session
-  cache.set("headerCache", {});
-
+  cache.del("headerCache");
   const app = express();
   let appStatus = false;
-
+  app.use(express.urlencoded({ extended: true })); // MUST be before your routes
   app.use(express.json({ limit: "50mb" }));
   app.use(
     cors({
@@ -49,150 +50,69 @@ async function expressMcpServer(mcpServer, cache, baseAppEnvContext) {
   const pkceStore = new Map(); // ourState -> { codeVerifier, clientRedirectUri, clientState }
   const codeStore = new Map(); // ourCode   -> { access_token, refresh_token, expires_in }
 
-  // Helper: build this server's base URL from appEnvBase
-  function serverBaseUrl() {
-    const appEnvBase = cache.get("appEnvBase");
-    const protocol = appEnvBase.HTTPS === "TRUE" ? "https" : "http";
-    return `${protocol}://localhost:${appEnvBase.PORT}`;
-  }
+  app.get('/.well-known/oauth-protected-resource', (req, res) => {
+    let payload = {
+      resource: `${baseAppEnvContext.mcpHost}/mcp`,
+      authorization_servers: [`${baseAppEnvContext.VIYA_SERVER}`],
+      scopes_supported: ['openid'],
+      bearer_methods_supported: ["header"]
+    }
+    console.error("[Note]>>>>>>>>>>>>>>>>>>>>>>>>>> protected resource metadata ", payload  );
+    return res.json(payload);
+  });
 
-  app.get("/.well-known/oauth-authorization-server", (req, res) => {
-    const base = serverBaseUrl();
-    let metadata = {
-      "issuer": base,
-      "authorization_endpoint": `${base}/oauth/authorize`,
-      "token_endpoint": `${base}/oauth/token`,
-      "response_types_supported": ["code"],
-      "grant_types_supported": ["authorization_code", "refresh_token"],
-      "code_challenge_methods_supported": ["S256"]
-    };
+  app.get("/.well-known/oauth-authorization-server", async (req, res) => {
+    console.error("[Note] Received request for OAuth authorization server metadata");
+    let metadata = getMetadata(req, res, baseAppEnvContext);
+    console.error("[Note]>>>>>>>>>>>>>>>>>>>>>>>>> metadata ", metadata);
     return res.status(200).json(metadata);
   });
 
   // OAuth authorize — generates PKCE params, stores state, redirects to SAS Viya
-  app.get("/oauth/authorize", (req, res) => {
-    const { response_type, redirect_uri, state, scope } = req.query;
-
-    if (response_type !== "code") {
-      return res.status(400).json({ error: "unsupported_response_type" });
-    }
-    if (!redirect_uri) {
-      return res.status(400).json({ error: "invalid_request", error_description: "redirect_uri is required" });
-    }
-
-    const codeVerifier = randomBytes(64).toString("base64url");
-    const codeChallenge = createHash("sha256").update(codeVerifier).digest("base64url");
-    const ourState = randomBytes(16).toString("hex");
-
-    pkceStore.set(ourState, { codeVerifier, clientRedirectUri: redirect_uri, clientState: state });
-
-    const callbackUri = `${serverBaseUrl()}/callback`;
-    const params = new URLSearchParams({
-      response_type: "code",
-      client_id: baseAppEnvContext.CLIENTID,
-      redirect_uri: callbackUri,
-      scope: scope || "openid",
-      state: ourState,
-      code_challenge: codeChallenge,
-      code_challenge_method: "S256",
-    });
-
-    console.error("[Note] OAuth authorize: redirecting to SAS Viya");
-    return res.redirect(`${baseAppEnvContext.VIYA_SERVER}/SASLogon/oauth/authorize?${params}`);
+  app.get("/oauth/authorize", async (req, res) => {
+    console.error("[Note] Received request for /oauth/authorize");
+    return authorize(req, res, baseAppEnvContext, pkceStore, codeStore);
+  });
+  app.get("/authorize", async (req, res) => {
+    console.error("[Note] Received request for /authorize");
+    return authorize(req, res, baseAppEnvContext, pkceStore, codeStore);
   });
 
-  // OAuth callback — receives code from SAS Viya, exchanges for tokens, redirects to MCP client
+  // OAuth callback — receives code from SAS Viya, exchanges for tokens
   app.get("/callback", async (req, res) => {
-    const { code, state, error, error_description } = req.query;
-
-    if (error) {
-      console.error("[Error] OAuth callback error:", error, error_description);
-      return res.status(400).send(`Authorization failed: ${error} — ${error_description ?? ""}`);
-    }
-
-    const pending = pkceStore.get(state);
-    if (!pending) {
-      return res.status(400).send("Invalid or expired state parameter");
-    }
-    pkceStore.delete(state);
-
-    const callbackUri = `${serverBaseUrl()}/callback`;
-
-    try {
-      const body = new URLSearchParams({
-        grant_type: "authorization_code",
-        client_id: baseAppEnvContext.CLIENTID,
-        redirect_uri: callbackUri,
-        code,
-        code_verifier: pending.codeVerifier,
-      });
-
-      const connectOpts = baseAppEnvContext.contexts?.appCert
-        ? baseAppEnvContext.contexts.appCert
-        : { rejectUnauthorized: false };
-      const agent = new Agent({ connect: connectOpts });
-
-      const response = await undiciFetch(`${baseAppEnvContext.VIYA_SERVER}/SASLogon/oauth/token`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-          "Accept": "application/json",
-        },
-        body: body.toString(),
-        dispatcher: agent,
-      });
-
-      if (!response.ok) {
-        const errText = await response.text();
-        console.error("[Error] SAS Viya token exchange failed:", errText);
-        return res.status(502).send("Token exchange with SAS Viya failed");
-      }
-
-      const tokens = await response.json();
-      const ourCode = randomUUID();
-      codeStore.set(ourCode, {
-        access_token: tokens.access_token,
-        refresh_token: tokens.refresh_token,
-        expires_in: tokens.expires_in,
-      });
-
-      const redirectParams = new URLSearchParams({ code: ourCode });
-      if (pending.clientState) {
-        redirectParams.set("state", pending.clientState);
-      }
-
-      console.error("[Note] OAuth callback complete, redirecting to MCP client");
-      return res.redirect(`${pending.clientRedirectUri}?${redirectParams}`);
-    } catch (err) {
-      console.error("[Error] OAuth callback handler error:", err);
-      return res.status(500).send("Internal server error during token exchange");
-    }
+    console.error("[Note] Received request for /callback with query parameters:");
+    return await callback(req, res, pkceStore, codeStore, baseAppEnvContext);
   });
 
   // OAuth token endpoint — MCP client exchanges intermediate code for access token
-  app.post("/oauth/token", express.urlencoded({ extended: false }), (req, res) => {
-    const { grant_type, code } = req.body;
+  app.post("/oauth/token", (req, res) => {
+    console.error("[Note] Received request for /oauth/token");
+    return token(req, res, baseAppEnvContext, codeStore, cache);
+  });
 
-    if (grant_type !== "authorization_code") {
-      return res.status(400).json({ error: "unsupported_grant_type" });
-    }
+  app.post("/token", (req, res) => {
+    console.error("[Note] Received request for /token");
+    return token(req, res, baseAppEnvContext, codeStore, cache);
+  });
+  // setup routes
 
-    const tokenData = codeStore.get(code);
-    if (!tokenData) {
-      return res.status(400).json({ error: "invalid_grant", error_description: "Invalid or expired authorization code" });
-    }
-    codeStore.delete(code);
-
-    console.error("[Note] OAuth token issued via code exchange");
-    return res.json({
-      access_token: tokenData.access_token,
-      token_type: "Bearer",
-      expires_in: tokenData.expires_in,
-      ...(tokenData.refresh_token && { refresh_token: tokenData.refresh_token }),
+  // Root endpoint info
+
+  app.get("/", (req, res) => {
+    res.json({
+      name: "SAS Viya Sample MCP Server",
+      version: baseAppEnvContext.version,
+      description: "SAS Viya Sample MCP Server",
+      endpoints: {
+        mcp: "/mcp",
+        health: "/health",
+        apiMeta: "/apiMeta"
+      },
+      usage: "Use with MCP Inspector or compatible MCP clients",
     });
   });
 
-  // setup routes
+  // health endpoint
   app.get("/health", (req, res) => {
     console.error("Received request for health endpoint");
     if (appStatus === false) {
@@ -213,22 +133,6 @@ async function expressMcpServer(mcpServer, cache, baseAppEnvContext) {
     res.json(health);
   });
 
-  // Root endpoint info
-
-  app.get("/", (req, res) => {
-    res.json({
-      name: "SAS Viya Sample MCP Server",
-      version: baseAppEnvContext.version,
-      description: "SAS Viya Sample MCP Server",
-      endpoints: {
-        mcp: "/mcp",
-        health: "/health",
-        apiMeta: "/apiMeta"
-      },
-      usage: "Use with MCP Inspector or compatible MCP clients",
-    });
-  });
-
   // api metadata endpoint(for sas specs)
   app.get("/apiMeta", (req, res) => {
     let spec = openAPIJson(baseAppEnvContext.version);
@@ -243,41 +147,7 @@ async function expressMcpServer(mcpServer, cache, baseAppEnvContext) {
 
   // handle processing of information in header.
   function requireBearer(req, res, next) {
-    // process any new header information
-    console.error("=======================================================");
-    console.error("Processing headers for incoming request to /mcp endpoint");
-    // Allow different VIYA server per sessionid(user)
-    let headerCache = {};
-    if (req.header("X-VIYA-SERVER") != null) {
-      console.error("[Note] Using user supplied VIYA server");
-      headerCache.VIYA_SERVER = req.header("X-VIYA-SERVER");
-    }
-
-    // used when doing autorization via mcp client
-    // ideal for production use
-    const hdr = req.header("Authorization");
-    if (hdr != null) {
-      headerCache.bearerToken = hdr.slice(7);
-      headerCache.AUTHFLOW = "bearer";
-      console.error("[Note] Using user supplied bearer token for authorization");
-      console.error("[Debug] Bearer token starts with:", headerCache.bearerToken);
-    } else {
-      console.error("[Note] No bearer token supplied in Authorization header");
-      headerCache.bearerToken = null;
-    }
-
-    // faking out api key since Viya does not support 
-    // not ideal for production
-    const hdr2 = req.header("X-REFRESH-TOKEN");
-    if (hdr2 != null) {
-      headerCache.REFRESH_TOKEN = hdr2;
-      headerCache.AUTHFLOW = "refresh";
-      console.error("[Note] Using user supplied refresh token for authorization");
-    }
-    cache.set("headerCache", headerCache);
-    next();
-    console.error("Finished processing headers for /mcp request");
-    console.error("=======================================================");
+    return processHeaders(req, res, next, cache, baseAppEnvContext);
   }
 
   // process mcp endpoint requests
@@ -357,9 +227,7 @@ async function expressMcpServer(mcpServer, cache, baseAppEnvContext) {
           cache.set(sessionId, _appContext);
         } else {
           let headerCache = cache.get("headerCache");
-          console.error('compare tokens', headerCache.bearerToken === _appContext.bearerToken);
           _appContext = Object.assign(_appContext, headerCache);
-          console.error('New bearerToken:', _appContext.bearerToken);
           cache.set(sessionId, _appContext);
         }
         console.error("[Note] Using existing transport for session ID:", sessionId);

package/src/oauthHandlers/authorize.js

@@ -0,0 +1,46 @@
+//authorize
+import { randomBytes, createHash } from "node:crypto";
+import baseUrl from "./baseUrl.js";
+
+function authorize(req, res, appContext, pkceStore, codeStore) {
+    const { response_type, redirect_uri, state, scope } = req.query;
+    console.error("===============================================================");
+    if (appContext.AUTHEXTERNAL === true) {
+        console.error('*************************************************************');
+        console.error("[Error] Received request for /authorize endpoint with external authorization expected");
+        console.error('*************************************************************');
+    }
+    console.error("[NOTE] query parameters:", { response_type, redirect_uri, state, scope });
+    if (response_type !== "code") {
+        return res.status(400).json({ error: "unsupported_response_type" });
+    }
+    if (!redirect_uri) {
+        return res.status(400).json({ error: "invalid_request", error_description: "redirect_uri is required" });
+    }
+
+    const codeVerifier = randomBytes(64).toString("base64url");
+    const codeChallenge = createHash("sha256").update(codeVerifier).digest("base64url");
+    const ourState = randomBytes(16).toString("hex");
+
+    pkceStore.set(ourState, { codeVerifier, clientRedirectUri: redirect_uri, clientState: state, codeChallenge });
+
+    const callbackUri = appContext.mcpHost + '/callback';
+    console.error("[Note] callbackUri:", callbackUri);
+    let urlConfig = {
+        response_type: "code",
+        client_id: appContext.CLIENTID,
+        redirect_uri: callbackUri,
+        scope: "openid",
+        state: ourState,
+        code_challenge: codeChallenge,
+        code_challenge_method: "S256"
+    }
+    if (appContext.PKCE !== "TRUE") {
+        urlConfig.client_secret = appContext.CLIENTSECRET;
+    }
+    console.error("[Note] Params for SAS Viya authorization request:", urlConfig);
+    const params = new URLSearchParams(urlConfig);
+    console.error("================================================================");
+    return res.redirect(`${appContext.VIYA_SERVER}/SASLogon/oauth/authorize?${params}`);
+}
+export default authorize;

package/src/oauthHandlers/baseUrl.js

@@ -0,0 +1,8 @@
+function baseUrl(appContext) {
+    const protocol = appContext.HTTPS === "TRUE" ? "https" : "http";
+    //const host = "localhost";
+    const host = appContext.VIYA_SERVER;
+    return host;
+    return `${protocol}://${host}:${appContext.PORT}`;
+}
+export default baseUrl;

package/src/oauthHandlers/callback.js

@@ -0,0 +1,96 @@
+import baseUrl from "./baseUrl.js";
+import { Agent, fetch as undiciFetch } from "undici";
+import { randomUUID } from "node:crypto";
+async function callback(req, res, pkceStore, codeStore, appContext) {
+  console.error("===============================================================");
+  console.error("[Note] OAuth callback");
+  console.error(req.query);
+  const {code, state} = req.query;
+
+  console.error("[Note] query parameters:", code, state);
+  if (!code) {  
+    return res.status(400).send("Missing code parameter");
+  }
+
+  const pending = pkceStore.get(state);
+  if (!pending) {
+    return res.status(400).send("Invalid or expired state parameter");
+  }
+  pkceStore.delete(state);
+
+  // const callbackUri = `${baseUrl(appContext)}/callback`;
+  const callbackUri = appContext.mcpHost + '/callback';
+  console.error("[Note] callbackUri for token exchange:", callbackUri);
+  try {
+    const body = new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: appContext.CLIENTID,
+      code: code,
+      redirect_uri: callbackUri,
+      code_verifier: pending.codeVerifier
+    }).toString();
+   
+    console.error("[Note] Token request body:", body.toString());
+  
+    let connectOpts = {
+      rejectUnauthorized: false  // or false, if you really want to bypass checks
+    }
+    if (appContext.contexts.viyaCert != null && appContext.contexts.viyaCert.ca != null) {
+      connectOpts.ca = appContext.contexts.viyaCert.ca;
+    }
+    const agent = new Agent({ connect: connectOpts });
+    console.error("[Note] Initiating token exchange with SAS Viya");
+    let clientID= appContext.CLIENTID;
+    let h = buildBasicAuthFromClientId(clientID);
+    // console.error("[Note] Authorization header for token request:", h);
+    const response = await undiciFetch(`${appContext.VIYA_SERVER}/SASLogon/oauth/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Accept": "application/json"
+      },
+      body: body,
+      dispatcher: agent,
+    });
+
+    if (!response.ok) {
+      const errText = await response.text();
+      console.error("[Error] SAS Viya token exchange failed:", errText);
+      return res.status(502).send("Token exchange with SAS Viya failed");
+    }
+
+    const tokens = await response.json();
+   // console.error("[Note] Received tokens from SAS Viya:", tokens);
+    const ourCode = randomUUID();
+    codeStore.set(ourCode, {
+      access_token: tokens.access_token,
+      refresh_token: tokens.refresh_token,
+      expires_in: tokens.expires_in,
+    });
+
+    const redirectParams = new URLSearchParams({ code: ourCode , state: pending.clientState});
+    //pending.clientState is the original state from the MCP client, which we should pass back to it for correlation
+
+    // pending.clientRedirectUri is the original redirect URI from the MCP client, 
+    // which was part of the payload from the client to /oauth/authorize
+    // we trust since it was associated with the valid PKCE state
+    console.error("[Note] OAuth callback complete, redirecting to MCP client");
+    console.log(pending.clientRedirectUri.toString())
+    return res.redirect(`${pending.clientRedirectUri}?${redirectParams}`);
+  } catch (err) {
+    console.error("[Error] OAuth callback handler error:", err);
+    return res.status(500).send("Internal server error during token exchange");
+  }
+
+  function buildBasicAuthFromClientId(clientId) {
+    const raw = `${clientId}:`;   // empty client_secret
+    const encoded =
+      typeof btoa === "function"
+        ? btoa(raw)
+        : Buffer.from(raw).toString("base64");
+
+    return `Basic ${encoded}`;
+  }
+
+}
+export default callback;

package/src/oauthHandlers/getMetadata.js

@@ -0,0 +1,27 @@
+import baseUrl from "./baseUrl.js";
+function getMetadata(req, res, appEnvContext) {
+    let base = '';
+    let host = '';
+    if (appEnvContext.AUTHEXTERNAL === true) {
+        base = appEnvContext.VIYA_SERVER + '/SASLogon';
+        host = appEnvContext.VIYA_SERVER;
+    } else {
+        base = appEnvContext.mcpHost;
+        host = appEnvContext.mcpHost;
+    } 
+    console.error(`[Note] Base URL for Authorization Server Metadata: ${base}`);
+    let metadata = {
+        "issuer": host,
+        "authorization_endpoint": `${base}/oauth/authorize`,
+        "token_endpoint": `${base}/oauth/token`,
+        "response_types_supported": ["code"],
+        "grant_types_supported": ["authorization_code", "refresh_token"],
+        "code_challenge_methods_supported": ["S256"],
+        "scopes_supported": ["openid"]
+    };
+    console.error("===============================================================");
+    console.error("[Note] Authorization Server Metadata:", metadata);
+    console.error("===============================================================");
+    return metadata;
+};
+export default getMetadata;

package/src/oauthHandlers/index.js

@@ -0,0 +1,7 @@
+import authorize from "./authorize.js";
+import callback from "./callback.js";   
+import token from "./token.js";
+import getMetadata from "./getMetadata.js";
+import baseUrl from "./baseUrl.js";
+
+export { authorize, callback, token, getMetadata, baseUrl };

package/src/oauthHandlers/token.js

@@ -0,0 +1,37 @@
+function token(req, res, appContext, codeStore, cache) {
+  console.error("===============================================================");
+  console.error("[Note] at /token endpoint");
+  console.error("[Note] Request headers:", req.headers);
+  console.error("[Note] Handling token request with body:", req.body);
+
+  const { grant_type, code } = req.body;
+  console.error("[Note] OAuth token request received for code:", code);
+  console.error("[Note] Grant type:", grant_type);
+
+  const tokenData = codeStore.get(code);
+  if (!tokenData) {
+    return res.status(400).json({ error: "Invalid_code", error_description: "Invalid or expired authorization code" });
+  }
+  console.error("[Note] Retrieved token data for code:", Object.keys(tokenData));
+ 
+  let payload = {
+    access_token: code, // tokenData.access_token,
+    token_type: "Bearer",
+    expires_in: tokenData.expires_in,
+    scope: "openid" // You can include scopes if you have them, e.g., tokenData.scope
+   // scope: tokenData.scope,
+  };
+  let tokenlist = cache.get("tokenlist");
+  tokenData.refreshAt = Date.now() + tokenData.expires_in * 1000; // Set refresh time based on expires_in
+  tokenlist[code] = tokenData;
+  cache.set("tokenlist", tokenlist);
+
+  codeStore.delete(code); // Invalidate the code after use
+  console.error("[Note] Returning token to client");
+  console.error("[Note] Token sent to client:", JSON.stringify(payload, null, 2));
+ 
+  console.error("============================================================")
+  return res.status(200).json(payload);
+}
+
+export default token;

package/src/processHeaders.js

@@ -0,0 +1,88 @@
+import { start } from "node:repl";
+
+/*
+ * Copyright © 2026, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import baseUrl from "./oauthHandlers/baseUrl.js";
+function processHeaders(req, res, next, cache, appContext) {
+
+  // process any new header information
+  debugger;
+  console.error("=======================================================");
+  console.error("Processing headers for incoming request to /mcp endpoint");
+  // Allow different VIYA server per sessionid(user)
+  cache.del("headerCache");
+  let headerCache = {};
+  if (req.header("X-VIYA-SERVER") != null) {
+    console.error("[Note] Using user supplied VIYA server");
+    headerCache.VIYA_SERVER = req.header("X-VIYA-SERVER");
+  }
+
+  // fakeapi key since Viya does not support it
+  // not ideal for production, just for testing
+  const hdr2 = req.header("X-REFRESH-TOKEN");
+  if (hdr2 != null) {
+    headerCache.REFRESH_TOKEN = hdr2;
+    headerCache.AUTHFLOW = "refresh";
+    console.error("[Note] Using user supplied refresh token for authorization");
+  }
+
+  // Oauth flow
+  const hdr = req.header("Authorization");
+  //for now, ignore Authorization if authflow is not bearer
+  let token = (hdr != null) ? hdr.slice(7) : null;
+  //console.error("[Note] Authorization token", token);
+  debugger;
+  console.log('>>>',appContext.AUTHFLOW);
+  if (appContext.AUTHFLOW === 'bearer') {
+    debugger;
+    let startAuth = false;
+    console.error("[Note] appContext.AUTHEXTERNAL:", appContext.AUTHEXTERNAL);
+    if (appContext.AUTHEXTERNAL === true) {
+      console.error("[Note] Expecting external authorization"); 
+      if (token != null) {
+        console.error("[Note] Using user supplied token for authorization");
+        headerCache.bearerToken = token;
+      } else {
+        startAuth = true;
+      }
+    } else  if (token == null) {
+      console.error("[Note] No Authorization token provided in header.");
+       startAuth = true;
+    } else {
+      console.error("[Note] Checking token against cache", token);
+      let tokenlist = cache.get("tokenlist");
+      let tokenData = tokenlist[token];
+      if (tokenData == null) {
+        return res.status(403).json({
+          error: "unauthorized",
+          error_description: "[Error] Expired token. Clear token and try again."
+        });
+      } else {
+        token = tokenData.access_token;
+        headerCache.bearerToken = token;
+      }
+    }
+    if (startAuth === true) {
+      // start oauth flow process
+      console.error(`[Note] No Authorization header provided.
+                            Returning 401 to start the OAuth flow`); 
+      const base = appContext.mcpHost;
+      res.set(
+        "WWW-Authenticate",
+        `Bearer resource_metadata="${base}/.well-known/oauth-authorization-server", scope="openid"`
+      );
+      return res.status(401).json({
+        error: "unauthorized",
+        error_description: "Bearer token required."
+      });
+      // start auth flow process since no token provided in header and we are not configured for external token
+    }
+  }
+ // console.error("Header cache after processing:", headerCache);
+  cache.set("headerCache", headerCache);
+  next();
+}
+
+export default processHeaders;

package/src/setupSkills.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+function setupSkills(clientName) {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    // Paths
+    let client = (clientName == null) ? '.github' : `.${clientName.toLowerCase()}`;
+    const source = path.join(__dirname, `../.skills`); 
+    const destination = path.join(os.homedir(), client);
+    console.error(`📁 Copying ${source} to ${destination}...`);
+    function copyFolderSync(from, to) {
+        if (!fs.existsSync(from)) return;
+        if (!fs.existsSync(to)) fs.mkdirSync(to, { recursive: true });
+        console.error(`📁 Copying folder: ${from} to ${to}`);
+        fs.readdirSync(from).forEach(element => {
+            console.error(`📁 Processing: ${element}`);
+            const fromPath = path.join(from, element);
+            const toPath = path.join(to, element);
+            if (fs.lstatSync(fromPath).isFile()) {
+                fs.copyFileSync(fromPath, toPath);
+            } else if (fs.lstatSync(fromPath).isDirectory()) {
+                copyFolderSync(fromPath, toPath);
+            }
+        });
+    }
+
+    try {
+        copyFolderSync(source, destination);
+        console.error(`✅ Success: ${destination} folder is now in your project root.`);
+    } catch (err) {
+        console.error('❌ Error copying files:', err.message);
+    }
+}
+export default setupSkills;

package/src/toolHelpers/_listLibrary.js

@@ -12,7 +12,6 @@ async function _listLibrary(params) {
  
   const _ilistLibrary = async (params) => {
     let { server, limit, start, name, _appContext } = params;
-    console.error(_appContext);
     let config = {
       casServerName: _appContext.cas,
       computeContext: _appContext.sas,