@sassoftware/sas-score-mcp-serverjs 1.0.1-2 → 1.0.1-22

package/.skills/skills/read-strategy/SKILL.md

@@ -0,0 +1,134 @@
+---
+name: read-strategy
+description: >
+  Strategy for reading data from CAS or SAS tables. Determines which read tool to use (raw reads vs analytical queries).
+---
+
+# Read Table Strategy
+
+Use this strategy when the user requests to read, fetch, or query data from a table.
+
+## Prerequisites
+
+Before reading:
+1. Verify the table exists using FIND-RESOURCE strategy
+2. Determine the server (CAS or SAS) from Step 1
+
+---
+
+## Two Types of Read Operations
+
+### Type 1: Raw Row Read
+
+**Trigger phrases**: "read rows from", "show first N records", "fetch records where", "get data from table"
+
+**Tool**: `sas-score-read-table`
+
+**When to use**:
+- User wants raw records, not aggregations
+- User wants to filter by WHERE clause
+- User wants to browse data
+
+**Parameters**:
+```
+lib: "<library>"           # from FIND-RESOURCE verification
+table: "<table>"           # from FIND-RESOURCE verification
+server: "cas" or "sas"     # from FIND-RESOURCE verification
+start: <row number>        # default 1
+limit: <max rows>          # default 10, max 1000
+where: "<SQL WHERE clause>"  # optional filter
+format: true               # default: use formatted values
+```
+
+**Example**:
+```
+sas-score-read-table({
+  lib: "Public",
+  table: "customers",
+  server: "cas",
+  limit: 25,
+  where: "status='active'"
+})
+```
+
+---
+
+### Type 2: Analytical Query
+
+**Trigger phrases**: "how many", "count by", "average", "total", "sum", "group by", "aggregate", "distinct", "join"
+
+**Tool**: `sas-score-sas-query`
+
+**When to use**:
+- User wants aggregations (SUM, AVG, COUNT, etc.)
+- User wants GROUP BY or distinct counts
+- User wants JOIN across tables
+- User wants statistical summaries
+
+**Parameters**:
+```
+table: "lib.table"         # CAS: "Public.customers", SAS: "SASHELP.cars"
+query: "<natural language question>"
+sql: "<SELECT SQL>"        # optional: pre-generated SQL
+```
+
+**Example**:
+```
+sas-score-sas-query({
+  table: "Public.customers",
+  query: "count of customers by region and status",
+  sql: "SELECT region, status, COUNT(*) as count FROM Public.customers GROUP BY region, status"
+})
+```
+
+---
+
+## Decision Tree
+
+```
+User requests data from table
+  ↓
+Is it an aggregation? (count, sum, avg, group by, distinct, etc.)
+  ├─ YES → Use sas-score-sas-query
+  └─ NO → Use sas-score-read-table
+```
+
+---
+
+## Table Name Format
+
+- **CAS tables**: `Caslib.table` or `Public.customers` (lowercase caslib, mixed case table)
+- **SAS tables**: `LIBREF.table` or `SASHELP.cars` (uppercase libref, case-insensitive table)
+
+---
+
+## Error Handling
+
+| Error | Action |
+|---|---|
+| Table not found | Verify table exists with FIND-RESOURCE first |
+| Server mismatch | Use server from FIND-RESOURCE verification |
+| Empty result | Ask user to adjust WHERE clause or criteria |
+| Column not found | Ask user to verify column name (case sensitivity) |
+
+---
+
+## Examples
+
+### Example 1: Browse customer records
+**Request**: "read first 20 customers from Public"
+1. Find table customers in Public → CAS
+2. Read: `sas-score-read-table({ lib: "Public", table: "customers", server: "cas", limit: 20 })`
+3. Return 20 rows
+
+### Example 2: Find active customers in a region
+**Request**: "fetch customers from Public where status='active' and region='East'"
+1. Find table customers in Public → CAS
+2. Read: `sas-score-read-table({ lib: "Public", table: "customers", server: "cas", where: "status='active' and region='East'" })`
+3. Return matching rows
+
+### Example 3: Aggregate customers by region
+**Request**: "how many customers by region in Public.customers"
+1. Find table customers in Public → CAS
+2. Query: `sas-score-sas-query({ table: "Public.customers", query: "count of customers by region", sql: "SELECT region, COUNT(*) FROM Public.customers GROUP BY region" })`
+3. Return aggregated result

package/.skills/skills/request-routing/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: request-routing
+description: >
+  Universal routing strategy for all SAS Viya requests. Every request follows the same three-step workflow.
+---
+
+# Universal Request Routing Strategy
+
+All SAS Viya requests follow this three-step workflow:
+
+## Step 1: Verify Resources Exist
+
+Before executing any action, verify that the target resources exist.
+
+| Resource Type | Find Tool | Notes |
+|---|---|---|
+| Library | `sas-score-find-library` | Specify server (cas or sas). For tables, determine server here. |
+| Table | `sas-score-find-table` | Requires library name and server. |
+| MAS Model | `sas-score-find-model` | No server selection. |
+| Job | `sas-score-find-job` | No server selection. |
+| JobDef | `sas-score-find-jobdef` | No server selection. |
+| SCR Model | Skip verification | SCR models do not require pre-verification. |
+
+**Rule**: Always verify before executing. Exception: SCR models can be scored directly.
+
+---
+
+## Step 2: Execute the Request
+
+Once resources are verified to exist, select the appropriate execution tool:
+
+| Request Type | Tool | Input |
+|---|---|---|
+| Read table rows | `sas-score-read-table` | lib, table, server (from Step 1) |
+| Query table (aggregation) | `sas-score-sas-query` | lib.table, SQL query |
+| Score with MAS model | `sas-score-mas-score` | model name, scenario data |
+| Run Job | `sas-score-run-jobdef` | job name, scenario parameters |
+| Run JobDef | `sas-score-run-jobdef` | jobdef name, scenario parameters |
+| Score with SCR model | `sas-score-scr-score` | SCR URL, scenario data |
+
+---
+
+## Step 3: Merge Results
+
+Combine verification and execution results:
+
+- For **read/query**: Return rows as-is.
+- For **scoring**: Merge predictions with input scenario data.
+- For **jobs/jobdefs**: Return execution results (tables, logs).
+
+---
+
+## Special Case: Read + Score (Combined Workflow)
+
+When the user requests scoring records from a table:
+
+1. **Verify**: Find the table (determine server), find the model.
+2. **Read**: Fetch rows from the table using `sas-score-read-table` or `sas-score-sas-query`.
+3. **Map**: Check if table columns match model input variables. Ask user for mapping if needed.
+4. **Score**: Score each row using `sas-score-mas-score` (for MAS) or `sas-score-scr-score` (for SCR).
+5. **Merge**: Combine predictions with original rows.
+
+---
+
+## Error Handling
+
+| Error | Action |
+|---|---|
+| Resource not found | Ask user to verify name and server (for tables). |
+| Column/input mismatch | Ask user to map table columns to model inputs. |
+| Empty result | Ask whether to adjust filter/criteria. |
+
+---
+
+## Examples
+
+### Example 1: Read a table
+**Request**: "read customers in Public"
+1. Find library Public → Verified (CAS)
+2. Read table customers in Public (CAS)
+3. Return rows
+
+### Example 2: Score with inline scenario
+**Request**: "score a=1, b=2 with model simplejob.job"
+1. Find job simplejob → Verified
+2. Run simplejob with scenario {a: 1, b: 2}
+3. Return result
+
+### Example 3: Score records from table
+**Request**: "score records from Public.customers with model risk_model.mas"
+1. Find table customers in Public → Verified (CAS)
+2. Find model risk_model → Verified (MAS)
+3. Read rows from Public.customers
+4. Score each row with risk_model
+5. Return merged predictions + original data

package/.skills/skills/score-strategy/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: score-strategy
+description: >
+  Unified scoring workflow. Handles MAS, Job, JobDef, SCR, and combined read+score scenarios.
+  Always verify resources before scoring.
+---
+
+# Score Strategy
+
+Use this strategy when the user requests model scoring, predictions, or running jobs/jobdefs.
+
+## Prerequisites
+
+1. Verify the model/job exists using find-resources skill
+2. If scoring table rows: Verify the table exists and determine server using find-resources skill
+3. If scoring with inline scenario: Parse the scenario data
+
+---
+
+## Step 1: Parse the Score Request
+
+Identify the scoring target (model type) and input source:
+
+### Identify Model Type
+
+```
+score with model X.mas       → MAS model
+score with model X.job       → Job
+score with model X.jobdef    → JobDef
+score with model X.scr       → SCR model
+score with model X           → Default to MAS
+```
+
+### Identify Input Source
+
+```
+score a=1, b=2               → Inline scenario
+score with scenario {...}    → Inline scenario
+score records from table X   → Table rows
+score results of query...    → Query results
+```
+
+---
+
+## Step 2: Execute Scoring
+
+### Option A: Score with Inline Scenario
+
+**Trigger phrases**: "score a=1, b=2", "predict with values", "score scenario"
+
+**Tools**:
+- MAS: `sas-score-mas-score`
+- Job: `sas-score-run-job`
+- JobDef: `sas-score-run-jobdef`
+- SCR: `sas-score-scr-score`
+
+**Flow**:
+1. Find model (find-resources)
+2. Score with inline data
+3. Return prediction + input data merged
+
+**Parameters** (MAS):
+
+```
+sas-score-mas-score({
+  model: "<model name>",
+  scenario: { a: 1, b: 2 }  
+```
+**Parameters** (job):                                           ):
+```
+sas-score-run-job({
+  name: "<job name>",
+  scenario: { a: 1, b: 2 }
+})
+```
+
+**Parameters** (jobdef):
+```
+sas-score-run-jobdef({
+  name: "<jobdef name>",
+  scenario: { a: 1, b: 2 }
+})
+```
+
+**Parameters** (SCR):
+```
+sas-score-scr-score({
+  url: "<scr endpoint>",
+  scenario: { a: 1, b: 2 }
+})
+```
+
+---
+
+### Option B: Score Table Rows (Read + Score)
+
+**Trigger phrases**: "score records from", "run model on table", "predict for customers in", "score rows from"
+
+**Flow**:
+1. Find model (find-resources)
+2. Find table (find-resources) → get server
+3. Read rows from table (read-strategy)
+4. Score each row (or batch score)
+5. Merge predictions with original rows
+
+**Decision**: Read strategy first
+- If user requests aggregation: Use `sas-score-sas-query`
+- If user requests raw rows: Use `sas-score-read-table`
+
+**Example workflow**:
+```
+Request: "score records from Public.customers with model risk_model"
+
+1. Find table customers in Public → CAS
+2. Find model risk_model → MAS
+3. Read rows: sas-score-read-table({ lib: "Public", table: "customers", server: "cas", limit: 1000 })
+4. Score each row: for each row, sas-score-mas-score({ model: "risk_model", scenario: {row} })
+5. Merge: combine risk score with customer data
+```
+
+---
+
+## Step 3: Result Formatting
+
+### MAS Scoring Result
+
+Return merged object:
+```
+Input data + Prediction fields
+Example: { a: 1, b: 2, prediction: 0.85, probability_0: 0.15, probability_1: 0.85 }
+```
+
+### Job/JobDef Result
+
+Return execution output:
+```
+Tables, logs, listings as returned by job
+```
+
+### SCR Result
+
+Return merged object:
+```
+Input data + Prediction fields from SCR response
+```
+
+### Batch Scoring (Table Rows)
+
+Return rows with predictions appended:
+```
+[
+  { customer_id: 1, name: "Alice", ..., risk_score: 0.32 },
+  { customer_id: 2, name: "Bob", ..., risk_score: 0.78 },
+  ...
+]
+```
+
+---
+
+## Column/Variable Mapping
+
+If table columns don't match model input variable names:
+
+1. Ask user: "Which table column maps to model input X?"
+2. Wait for mapping: e.g., { customer_age: age, customer_income: income }
+3. Transform row data using mapping
+4. Score transformed data
+5. Return with original column names
+
+---
+
+## Error Handling
+
+| Error | Action |
+|---|---|
+| Model not found | Verify model name with user |
+| Table not found | Verify table name and library |
+| Scenario mismatch | Ask user to verify input variable names |
+| Empty table | Ask whether to adjust filter or continue |
+| Scoring failure | Return error message from scoring tool |
+
+---
+
+## Examples
+
+### Example 1: Score with inline scenario
+**Request**: "score a=1, b=2 with model simplejob.job"
+1. Find job simplejob using find-resources strategy
+2. Run: `sas-score-run-jobdef({ name: "simplejob", scenario: { a: 1, b: 2 } })`
+3. Return: `{ c: 3 }`
+
+### Example 2: Score with MAS model
+**Request**: "predict churn for age=45, income=60000 with model churn_predictor"
+1. Find model churn_predictor.mas using find-resources strategy
+2. Score: `sas-score-mas-score({ model: "churn_predictor", scenario: { age: 45, income: 60000 } })`
+3. Return: `{ age: 45, income: 60000, churn_probability: 0.23, prediction: "no_churn" }`
+
+### Example 3: Score table rows
+**Request**: "score all active customers with model risk_model and table Public.customers"
+1. Find model risk_model.mad using find-resources strategy
+2. Find table Public.customers using find-resources strategy
+3. Read: `sas-score-read-table({ lib: "Public", table: "customers", server: "cas", where: "status='active'" })`
+4. Score each row with risk_model
+5. Return: customers with risk_score appended
+
+### Example 4: Score with SCR model
+**Request**: "score age=50, income=75000 with model loan.scr"
+1. Prepare: SCR URL for "loan"
+2. Score: `sas-score-scr-score({ url: "loan", scenario: { age: 50, income: 75000 } })`
+3. Return predictions from SCR endpoint

package/README.md

@@ -196,7 +196,15 @@ NODE_EXTRA_CA_CERTS=c:\Users\<your_username>\AppData\Local\mkcert\rootCA.pem
 ```
 
 ## License
-This project is licensed under the [Apache 2.0 license](LICENSE).
+This project is licensed under the Apache License 2.0. See [LICENSE](LICENSE).
+
+The container image published from this repository also includes third-party software, each component under its own license:
+
+- The npm dependencies that ship with this project, along with their respective licenses, are listed in [LICENSES.json](LICENSES.json).
+- The container is built from the 25-alpine base image; license texts for its included software ship inside the image itself. License information for each Alpine package is available at [pkgs.alpinelinux.org](https://pkgs.alpinelinux.org/packages).
+
+As with any container image, direct and indirect dependencies are governed by their own licenses.
+Users of the published container image are responsible for ensuring that their use complies with all applicable licenses.
 
 ## Additional Resources
 

package/cli.js

@@ -9,15 +9,11 @@
 
 import coreSSE from './src/coreSSE.js';
 import expressMcpServer from './src/expressMcpServer.js';
-import hapiMcpServer from './src/hapiMcpServer.js';
-
 import createMcpServer from './src/createMcpServer.js';
 // import dotenvExpand from 'dotenv-expand';
 import fs from 'fs';
 import { randomUUID } from 'node:crypto';
 
-//import refreshToken from './src/toolHelpers/refreshToken.js';
-//import getOptsViya from './src/toolHelpers/getOptsViya.js';
 import readCerts from './src/toolHelpers/readCerts.js';
 
 import { fileURLToPath } from 'url';
@@ -27,7 +23,8 @@ import setupSkills from './src/setupSkills.js';
 import { parseArgs } from "node:util";
 
 import NodeCache from 'node-cache';
-import { be } from 'zod/locales';
+//import { be } from 'zod/locales';
+//import { auth } from '@modelcontextprotocol/sdk/client/auth';
 //import getOpts from './src/toolHelpers/getOpts.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -72,11 +69,6 @@ const args = parseArgs({
       short: 'c',
       description: 'Client ID for authentication'
     },
-    clientsecret: {
-      type: 'string',
-      short: 's',
-      description: 'Client Secret for authentication'
-    },
     profile: {
       type: 'string',
       description: 'SAS CLI profile name'
@@ -107,6 +99,17 @@ const args = parseArgs({
       alias: 'mcpclient',
       description: 'MCP client name (github, claude...). Defaults to \'github\''
     },
+    folder: {
+      type: 'string',
+      short: 'f',
+      description: 'Subfolder under the client folder to copy the skills to, used to have different set of skills for different agents under the same client'
+
+    },
+    skills: {
+      type: 'string',
+      short: 's',
+      description: 'Copies the skills for .github and .claude to the user home directory under .clientname (e.g. .github) or current directory if client name starts with dot (e.g. ./.github), used to have different set of skills for different clients'
+    },
     help: {
       type: 'boolean',
       short: 'h',
@@ -125,28 +128,28 @@ const args = parseArgs({
 // Handle help flag
 if (args.values.help) {
   console.error(`
-                SAS Viya Scoring Expert Agent - Version: ${JSON.parse(pkg).version}
+                sas-score-mcp-serverjs - Version: ${JSON.parse(pkg).version}
 
 Usage: npx @sassoftware/sas-score-mcp-serverjs@dev [options]
 
 Options:
   Minimal options:
     -v, --viya <url>               Viya server URL
-    -c, --clientid <id>            Client ID for oauth authentication(pkce preferred. default: vscodemcp)
   
   MCP server options:
     -t, --mcptype <type>           MCP server type: http or stdio (default: http)
     -m, --mcphost <host>           MCP server host - can be remote URL - (default: http://localhost:8080)
   
-  Agent options:
-    --agent                        Enable agent mode with a pre-configured set of skills based on the client specified (default: false)
-    --client <name>                MCP client name (github, claude...). Defaults to 'github'.Use to install skills
   Authentication options:
+    -c, --clientid <id>            Client ID for oauth authentication(pkce preferred. default: vscodemcp)
     -a, --authflow <flow>          Authentication flow: oauth, oauthclient, sascli, code, token(default oauth)
-    -s, --clientsecret <secret>   Client Secret for oauth authentication (not needed for pkce)
     --profile <name>               SAS CLI profile name for sascli flow (default: Default)
     --config <path>                SAS CLI config directory for sascli flow (default: user home directory)
 
+  Agent/skills options:
+    -s, --skills  <name>           Copies the skills for .github and .claude
+    -f, --folder <folder>          Subfolder to copy the skills to. ex: ./github/<folder>, used to have different set of skills for different agents under the same client. 
+ 
   Other options:
     -p, --port <port>              Port to run the server on (default: 8080)
     --https                        Use HTTPS for the server (default: false)
@@ -165,6 +168,13 @@ Environment Variables:
   `);
   process.exit(0);
 }
+if (args.values.skills) {
+  console.error(`[Note] Settings up skills for ${args.values.skills }`);
+  setupSkills(args.values.skills, args.values.folder);;
+  console.error(`[Note] Skills setup completed. `);
+  process.exit(0);
+}
+
 console.error('Parsed command line arguments:', args.values);
 // read env file and then override with command line arguments
 if (args.values.env) {
@@ -194,7 +204,7 @@ process.env.AUTHFLOW = args.values.authflow || process.env.AUTHFLOW || 'oauth';
 process.env.MCPCLIENT = args.values.client || process.env.MCPCLIENT || 'github';
 process.env.VIYA_SERVER = args.values.viya || process.env.VIYA_SERVER;
 process.env.CLIENTID = args.values.clientid || process.env.CLIENTID || 'vscodemcp';
-process.env.CLIENTSECRET = args.values.clientsecret || process.env.CLIENTSECRET || null;
+process.env.CLIENTSECRET = null;
 process.env.SAS_CLI_PROFILE = args.values.profile || process.env.SAS_CLI_PROFILE || 'Default';
 process.env.SAS_CLI_CONFIG = args.values.config || process.env.SAS_CLI_CONFIG || os.homedir(); // default to user home directory
 process.env.CASSERVER = args.values.casserver || process.env.CASSERVER || 'cas-shared-default';
@@ -219,6 +229,7 @@ if (args.values.version) {
 console.error(`[Note] MCP client set to: ${process.env.CLIENT}`);
 
 
+
 /********************************* */
 const BRAND = 'sas-score'
 /********************************* */
@@ -256,8 +267,10 @@ let mcpHost = process.env.MCPHOST;
 if (authFlow === 'oauth' || authFlow === 'oauthclient') {
   authFlow = 'bearer';
   authExternal = (authFlow === 'oauthclient') ? true : false;
+} else if (authFlow === 'bearer') {
+  authExternal = true; // in bearer token flow we assume the token is generated externally and passed in via env variable or token file, so we set authExternal to true to indicate that  
 }
-let autoLogon = process.env.AUTOLOGON != null ? process.env.AUTOLOGON.toUpperCase() : "FALSE";
+  let autoLogon = process.env.AUTOLOGON != null ? process.env.AUTOLOGON.toUpperCase() : "FALSE";
 const appEnvBase = {
   version: version,
   mcpType: mcpType,
@@ -373,10 +386,13 @@ if (appEnvBase.TOKENFILE != null) {
 
 // setup skills based on client before mcp initialization
 //
+
+
+
 if (process.env.AGENT === 'TRUE') {
   if (process.env.CLIENT !== 'none') {
     console.error(`[Note] Setting up skills for client: ${process.env.CLIENT}...`);
-    setupSkills(process.env.CLIENT);
+    setupSkills(process.env.CLIENT, args.values.folder); 
   } 
 } else {
     console.error(`[Note] Agent mode not enabled`);
@@ -453,14 +469,8 @@ if (mcpType === 'stdio') {
 
 } else {
   console.error('[Note] Starting HTTP MCP server...');
-  if (useHapi === true) {
-    process.env.AUTHTYPE = null;
-    await hapiMcpServer(mcpServer, sessionCache, appEnvBase);
-    console.error('[Note] Using HAPI HTTP server...')
-  } else {
-    await expressMcpServer(mcpServer, sessionCache, appEnvBase);
-    console.error('[Note] MCP HTTP express server started on port ' + appEnvBase.PORT);
-  }
+  await expressMcpServer(mcpServer, sessionCache, appEnvBase);
+  console.error('[Note] MCP HTTP express server started on port ' + appEnvBase.PORT);
 }
 
 // custom reader for .env file to avoid dotenv logging to console

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sassoftware/sas-score-mcp-serverjs",
-  "version": "1.0.1-2",
+  "version": "1.0.1-22",
   "description": "A mcp server for SAS Viya",
   "author": "Deva Kumar <deva.kumar@sas.com>",
   "license": "Apache-2.0",
@@ -46,11 +46,10 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@sassoftware/restaf": "^5.6.0",
-    "@sassoftware/restafedit": "^3.11.1-10",
-    "@sassoftware/restaflib": "^5.6.0",
-    "@sassoftware/viya-serverjs": "^0.6.3-0",
-    "axios": "^1.13.2",
+    "@sassoftware/restaf": "^5.7.2",
+    "@sassoftware/restafedit": "^3.10.5",
+    "@sassoftware/restaflib": "^5.7.2",
+    "axios": "^1.13.5",
     "body-parser": "^2.2.1",
     "cors": "^2.8.5",
     "cross-env": "^10.1.0",
@@ -62,8 +61,8 @@
     "node-cache": "^5.1.2",
     "open": "^11.0.0",
     "selfsigned": "^5.2.0",
-    "undici": "^7.16.0",
-    "uuid": "^13.0.0",
+    "undici": "^7.24.0",
+    "uuid": "^14.0.0",
     "zod": "^4.2.1"
   },
   "devDependencies": {

package/scripts/setup-skills.js

@@ -6,7 +6,7 @@ import os from 'os';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Paths
 let client = (process.env.CLIENTNAME == null) ? '.github' : `.${process.env.CLIENTNAME.toLowerCase()}`;
-const source = path.join(__dirname, `../.skills`);
+const source = path.join(__dirname, `../.github`);
 const destination = path.join(process.cwd(), client);
 // const destination = path.join(os.homedir(), client)
 console.error(`📁 Copying ${source} to ${destination}...`);

package/src/oauthHandlers/callback.js

@@ -75,7 +75,7 @@ async function callback(req, res, pkceStore, codeStore, appContext) {
     // 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())
+    console.error(pending.clientRedirectUri.toString())
     return res.redirect(`${pending.clientRedirectUri}?${redirectParams}`);
   } catch (err) {
     console.error("[Error] OAuth callback handler error:", err);

package/src/processHeaders.js

@@ -34,7 +34,7 @@ function processHeaders(req, res, next, cache, appContext) {
   let token = (hdr != null) ? hdr.slice(7) : null;
   //console.error("[Note] Authorization token", token);
   debugger;
-  console.log('>>>',appContext.AUTHFLOW);
+  console.error('>>>',appContext.AUTHFLOW);
   if (appContext.AUTHFLOW === 'bearer') {
     debugger;
     let startAuth = false;