@sassoftware/sas-score-mcp-serverjs 0.3.18 → 0.4.0

package/src/toolSet/runMacro.js

@@ -9,32 +9,32 @@ import _submitCode from '../toolHelpers/_submitCode.js';
 
 function runMacro(_appContext) {
   let description = `
-## run-macro
+run-macro — submit and execute a SAS macro on SAS Viya server.
 
-Submit and execute a SAS macro on a SAS Viya server by generating and sending SAS code.
+USE when: run macro, execute macro with parameters
+DO NOT USE for: arbitrary SAS code (use run-sas-program), jobs, jobdefs
 
-Inputs
-- macro (string, required): The name of the macro to execute (provide the macro identifier without the leading "%").
-- scenario (string, optional): Parameters or SAS setup code to send before invoking the macro. Accepted formats:
-  - Comma-separated key=value pairs (e.g. "x=1, y=abc") — converted to SAS %let statements.
-  - Raw SAS macro code (e.g. "%let x=1; %let y=abc;") — passed through unchanged when it already contains SAS macro syntax.
+PARAMETERS
+- macro: string — macro name without "%" (required)
+- scenario: string — parameters or setup code (optional). Accepts: "x=1, y=abc" or "%let x=1; %let y=abc;"
 
-Behavior
-- If \`scenario\` contains SAS macro syntax (contains \`%let\` or other macro markers), it is sent unchanged.
-- Otherwise the tool converts comma-separated parameters into \`%let\` statements (e.g. "x=1,y=abc" → "%let x=1; %let y=abc;") and appends a macro invocation \`%<macro>;\`.
-- The resulting SAS code is submitted via the internal \`_submitCode\` helper and the submission result is returned.
+ROUTING RULES
+- "run macro abc" → { macro: "abc", scenario: "" }
+- "run macro abc with x=1, y=2" → { macro: "abc", scenario: "x=1, y=2" }
+- "run macro xyz with %let a=1; %let b=2;" → { macro: "xyz", scenario: "%let a=1; %let b=2;" }
 
-Output
-- Returns the response produced by \`_submitCode\`, typically including ods, log, list of tables created by the macro
+EXAMPLES
+- "run macro abc" → { macro: "abc", scenario: "" }
+- "run macro summarize with x=1, y=2" → { macro: "summarize", scenario: "x=1, y=2" }
 
-Usage notes
-- Ensure the target SAS environment has the macro defined
-- This helper does not perform advanced input validation or type coercion — validate parameters before calling when needed.
+NEGATIVE EXAMPLES (do not route here)
+- "run SAS code" (use run-sas-program)
+- "run job X" (use run-job)
+- "run jobdef X" (use run-jobdef)
 
-Examples
-- run macro \`abc\` with scenario \`x=1, y=2\`
-- run macro \`summarize\` with raw SAS code \`%let x=1; %let y=2;\` (the helper will pass it through unchanged)
-`;
+ERRORS
+Returns log, ods, tables created by macro. Auto-converts "x=1, y=2" to "%let x=1; %let y=2;" format.
+  `;
 
   let spec = {
     name: 'run-macro',

package/src/toolSet/runProgram.js

@@ -8,84 +8,37 @@ import _submitCode from '../toolHelpers/_submitCode.js';
 
 function runProgram(_appContext) {
   let description = `
-## run-sas-program — execute SAS code or programs on SAS Viya server
+run-sas-program — execute SAS code or programs on SAS Viya server.
 
-LLM Invocation Guidance (When to use)
-Use THIS tool when the user wants to run a SAS program on the server:
-- "run program 'data a; x=1; run;'"
-- "execute this SAS code: proc print data=sashelp.cars; run;"
-- "program 'data work.a; x=1; run;' output=a limit=50"
-- "run sas program sample folder=/Public/models output=A limit=50"
-- "run sas program with parameters name=John, age=45"
-- "execute SAS file myprogram.sas from /Public folder"
+USE when: run program, execute SAS code, run .sas file
+DO NOT USE for: macros (use run-macro), jobs (use run-job), jobdefs (use run-jobdef), SQL queries (use sas-query), read data (use read-table)
 
-Do NOT use this tool when the user wants:
-- run macro -> use run-macro
-- run job -> use run-job
-- run jobdef -> use run-jobdef
-- list jobs -> use list-jobs
-- list jobdefs -> use list-jobdefs
-- find job -> use find-job
-- find jobdef -> use find-jobdef
-- find model -> use find-model
-- Query tables with SQL -> use sas-query
-- Read table data -> use read-table
+PARAMETERS
+- src: string — SAS code or .sas filename (required)
+- folder: string (default: '') — server folder path for .sas files
+- scenario: string | object — parameter values. Accepts: "x=1, y=2" or {x:1, y:2}
+- output: string (default: '') — table name to return (case-sensitive)
+- limit: number (default: 100) — max rows from output
 
-Purpose
-Execute SAS code or programs on a SAS Viya server. Can run inline SAS code or execute .sas files stored on the server. Supports parameter passing via scenario values and can return output tables.
-
-Parameters
-- src (string, required): The SAS program to execute. Can be either:
-  - Inline SAS code as a string (e.g., "data a; x=1; run;")
-  - Name of a .sas file stored on the server (used with folder parameter)
-- folder (string, default ''): Server folder path where the .sas file is located (e.g., "/Public/models")
-- scenario (string | object, optional): Input parameter values. Accepts:
-  - Comma-separated key=value string (e.g., "x=1, y=2")
-  - JSON object with field names and values (recommended)
-- output (string, default ''): Table name to return in response (case-sensitive)
-- limit (number, default 100): Maximum number of rows to return from output table
-
-Response Contract
-Returns a JSON object containing:
-- log: Execution log from SAS
-- ods: ODS output if generated
-- tables: Array of table names created during execution
-- data: If output parameter specified, returns the table data (up to limit rows)
-- error: Error message if execution fails
-- Empty content if no results produced
-
-Disambiguation & Clarification
-- Missing SAS code: ask "What SAS program or code would you like to execute?"
-- Inline code vs file unclear: ask "Do you want to run inline SAS code or execute a .sas file from the server?"
-- If output table not returned: clarify "The output table name is case-sensitive. Did you specify the exact name?"
-- If unclear about parameters: ask "What parameter values should I pass to the program?"
-
-Examples (→ mapped params)
+ROUTING RULES
 - "run program 'data a; x=1; run;'" → { src: "data a; x=1; run;", folder: "", output: "", limit: 100 }
-- "program 'data work.a; x=1; run;' output=a limit=50" → { src: "data work.a; x=1; run;", folder: "", output: "a", limit: 50 }
-- "run sas program sample folder=/Public/models output=A limit=50" → { src: "sample", folder: "/Public/models", output: "A", limit: 50 }
-- "run program mycode.sas in /Public with name=John, age=45" → { src: "mycode", folder: "/Public", scenario: { name: "John", age: 45 }, output: "", limit: 100 }
+- "run sas program sample folder=/Public/models" → { src: "sample", folder: "/Public/models", output: "", limit: 100 }
+- "run program with name=John, age=45" → { src: "<code>", scenario: {name:"John", age:45}, output: "", limit: 100 }
 
-Negative Examples (should NOT call run-sas-program)
-- "run macro summarize" (use run-macro instead)
-- "run job monthly_report" (use run-job instead)
-- "run jobdef etl_process" (use run-jobdef instead)
-- "how many customers by region in Public.customers" (use sas-query instead)
-- "read 10 rows from cars" (use read-table instead)
+EXAMPLES
+- "run program 'data a; x=1; run;'" → { src: "data a; x=1; run;", folder: "", output: "", limit: 100 }
+- "run sas file sample in /Public" → { src: "sample", folder: "/Public", output: "", limit: 100 }
 
-Behavior & Usage Notes
-- Sends the supplied src verbatim to the SAS execution helper
-- For .sas files, specify the file name (with or without .sas extension) and the folder path
-- For invoking pre-defined SAS macros, prefer run-macro which handles %let statements automatically
-- Scenario values are converted to macro variables when provided
-- Be cautious when executing arbitrary code in production environments
+NEGATIVE EXAMPLES (do not route here)
+- "run macro X" (use run-macro)
+- "run job X" (use run-job)
+- "run jobdef X" (use run-jobdef)
+- "SQL query" (use sas-query)
+- "read table" (use read-table)
 
-Related Tools
-- run-macro — for executing predefined SAS macros with parameters
-- run-job — for executing registered Job Execution assets
-- sas-query — for natural language SQL queries
-- read-table — for simple data retrieval
-`;
+ERRORS
+Returns log, ods, tables array, data (if output specified). Error if execution fails.
+  `;
 
   let spec = {
     name: 'run-sas-program',

package/src/toolSet/sasQuery.js

@@ -5,85 +5,38 @@
 import {z} from 'zod';
 import _jobSubmit from '../toolHelpers/_jobSubmit.js';
 
-
 function sasQuery() {
  
     let description = `
-## sas-query — convert natural language questions into SQL queries and execute them
-
-LLM Invocation Guidance (When to use)
-Use THIS tool when:
-- User asks a natural language question about table data: "how many customers by region?"
-- User wants aggregated analytics: "show total sales by year"
-- User needs complex filtering: "find all orders over $1000 from last month"
-- User requests joined data: "show products with their category names"
-- User wants statistical summaries: "average, min, max salary by department"
-- User asks for specific calculations: "percentage of customers by state"
-
-Do NOT use this tool for:
-- Reading raw table data without filtering (use read-table)
-- Getting table structure or column info (use table-info)
-- Running pre-written SAS programs (use run-sas-program)
-- Running jobs or job definitions (use run-job or run-jobdef)
-- Executing macros (use run-macro)
-- Simple table reads with no aggregation (use read-table)
-
-Purpose
-Convert natural language queries into SAS PROC SQL SELECT statements and execute them to retrieve analyzed data. The LLM generates the SQL from the natural language query, and this tool executes it against the specified table.
-
-Parameters
-- table (string, required): Table name in lib.table format (e.g., "Public.cars", "sashelp.class")
-- query (string, required): Natural language description of what data you want
-- sql (string, optional): Pre-generated SQL SELECT statement (LLM should generate this from the query)
-- job (string, default 'program'): Job name to execute the query (default is 'program')
-
-Behavior & Processing
-- LLM converts the natural language query into a valid SAS PROC SQL SELECT statement
-- Do not add semicolons to the end of SQL statements
-- SQL reference: https://go.documentation.sas.com/doc/en/pgmsascdc/v_067/sqlproc/n0w2pkrm208upln11i9r4ogwyvow.htm
-- Tool executes the generated SQL against the specified table
-- Returns data in JSON format
+sas-query — convert natural language questions into SQL queries and execute them.
 
-Response Contract
-Returns a JSON object containing:
-- rows: Array of row objects with query results
-- columns: Column metadata from the query result
-- log: Execution log if available
-- If error: structured error message
-- If more than 10 rows: only first 10 displayed (ask user if they want more)
+USE when: how many/count/total/average by, aggregated analytics, complex filtering, statistical summaries
+DO NOT USE for: raw reads without filtering (use read-table), table structure (use table-info), SAS programs (use run-sas-program), jobs/jobdefs
 
-Disambiguation & Clarification
-- If table missing: ask "Which table should I query (format: lib.tablename)?"
-- If query too vague: ask "Can you be more specific about what data or calculation you want?"
-- If table format unclear: ask "Please specify table as library.tablename (e.g., Public.cars)"
-- If ambiguous calculation: ask for clarification on what to aggregate or filter
+PARAMETERS
+- table: string — table in lib.table format (required), e.g. "Public.cars" or "sashelp.class"
+- query: string — natural language question (required)
+- sql: string — pre-generated SQL SELECT (optional, LLM generates)
+- job: string (default: 'program') — job name to execute
 
-Examples (→ mapped params)
-- "how many cars by make in sashelp.cars" → { table: "sashelp.cars", query: "how many cars by make", sql: "SELECT make, COUNT(*) AS count FROM sashelp.cars GROUP BY make" }
-- "average horsepower by origin" → { table: "sashelp.cars", query: "average horsepower by origin", sql: "SELECT origin, AVG(horsepower) AS avg_hp FROM sashelp.cars GROUP BY origin" }
-- "total sales over $1000 by region" → { table: "mylib.sales", query: "total sales over $1000 by region", sql: "SELECT region, SUM(amount) AS total FROM mylib.sales WHERE amount > 1000 GROUP BY region" }
-- "percentage of students by year in Public.students" → { table: "Public.students", query: "percentage by year", sql: "SELECT year, COUNT(*) * 100.0 / (SELECT COUNT(*) FROM Public.students) AS pct FROM Public.students GROUP BY year" }
+ROUTING RULES
+- "how many cars by make in sashelp.cars" → { table: "sashelp.cars", query: "how many cars by make", sql: "SELECT make, COUNT(*) FROM sashelp.cars GROUP BY make" }
+- "average salary by department in Public.employees" → { table: "Public.employees", query: "average salary by department", sql: "SELECT department, AVG(salary) FROM Public.employees GROUP BY department" }
 
-Negative Examples (should NOT call sas-query)
-- "read table cars from sashelp" (use read-table instead)
-- "show me 10 rows from customers" (use read-table instead)
-- "what columns are in the sales table?" (use table-info instead)
-- "run this SAS code: proc sql; select * from..." (use run-sas-program instead)
-- "execute job monthly_report" (use run-job instead)
-- "run macro summarize_data" (use run-macro instead)
+EXAMPLES
+- "how many cars by make in sashelp.cars" → { table: "sashelp.cars", query: "how many cars by make", sql: "SELECT make, COUNT(*) FROM sashelp.cars GROUP BY make" }
+- "total sales by region from mylib.sales" → { table: "mylib.sales", query: "total sales by region", sql: "SELECT region, SUM(amount) FROM mylib.sales GROUP BY region" }
 
-Usage Tips
-- Ensure table is specified in lib.tablename format
-- Be specific in natural language queries for better SQL generation
-- Use table-info first to understand column names and types
-- For simple reads without filtering/aggregation, prefer read-table
+NEGATIVE EXAMPLES (do not route here)
+- "read table cars" (use read-table)
+- "show 10 rows" (use read-table)
+- "table structure" (use table-info)
+- "run SAS code" (use run-sas-program)
+- "run job/macro" (use run-job/run-macro)
 
-Related Tools
-- read-table — for simple data reading without SQL queries
-- table-info — to inspect table schema before querying
-- run-sas-program — for executing pre-written SAS/SQL code
-- find-table — to verify table exists before querying
-`;
+ERRORS
+Returns rows array, columns metadata, log. Returns error if SQL invalid or table not found.
+  `;
 
 
     let spec = {

package/src/toolSet/scrInfo.js

@@ -15,7 +15,7 @@ Purpose
 Return the input/output schema and metadata for an SCR (Score Code Runtime) model.
 
 Inputs
-- name (string): The SCR model identifier. 
+- url (string): The SCR model identifier. 
 What it returns
 - A JSON object describing the model's interface, typically including:
   - Input variables (names, types, required/optional)
@@ -23,7 +23,6 @@ What it returns
   
 
 Usage notes
-- If no local mapping exists and \`name\` looks like a URL, the tool will attempt to fetch the schema from that URL.
 - Ensure network connectivity and credentials for the remote SCR service when needed.
 - Use scr-score to score data after inspecting the schema.
 
@@ -37,9 +36,9 @@ Examples
     aliases: ['scrInfo','scr info','scr_info'],
     description: description,
     schema: {
-      name: z.string(),
+      url: z.string(),
     },
-    required: ['name'],
+    required: ['url'],
     handler: async (params) => {
       let {url, _appContext} = params;
       if (url === null) {

package/src/toolSet/setContext.js

@@ -7,60 +7,34 @@ import {z} from 'zod';
 
 function setContext(_appContext) {
     let description = `
-## set-context — set the CAS and SAS server contexts for subsequent tool calls
+set-context — set the CAS and SAS server contexts for subsequent tool calls.
 
-LLM Invocation Guidance (When to use)
-Use THIS tool when:
-- User wants to switch to a different CAS server: "Use the finance-cas-server"
-- User wants to change the compute context: "Switch to 'SAS Studio Compute Context'"
-- User wants to check current context: "What context am I using?"
-- User wants to set both: "Use finance-cas-server for CAS and my-compute for SAS"
+USE when: switch to CAS server, change compute context, check current context, set both
+DO NOT USE for: get variables (use get-env), read data (use read-table), run programs (use run-sas-program)
 
-Do NOT use this tool for:
-- Retrieving variable values (use get-env)
-- Reading table data (use read-table)
-- Running programs or queries (use run-sas-program or sas-query)
-- Listing available servers or contexts (no tool for this; would require backend support)
+PARAMETERS
+- cas: string — CAS server name (optional), e.g. 'cas-shared-default', 'finance-cas-server'
+- sas: string — SAS compute context (optional), e.g. 'SAS Studio Compute Context', 'batch-compute'
 
-Purpose
-Set the active CAS server and/or SAS compute context for all subsequent tool calls in this session. This allows switching between different server environments. If neither parameter is provided, the tool returns the current context values.
+ROUTING RULES
+- "use finance-cas-server" → { cas: "finance-cas-server" }
+- "switch to SAS Studio Compute Context" → { sas: "SAS Studio Compute Context" }
+- "use finance-cas for CAS and batch-compute for SAS" → { cas: "finance-cas", sas: "batch-compute" }
+- "what context am I using" → { } (no params, returns current)
 
-Parameters
-- cas (string, optional): The name of the CAS server to use for subsequent CAS operations. Examples: 'cas-shared-default', 'finance-cas-server', 'analytics-cas'
-- sas (string, optional): The name of the SAS compute context to use for subsequent SAS operations. Examples: 'SAS Studio Compute Context', 'my-compute', 'batch-compute'
+EXAMPLES
+- "use finance-cas-server" → { cas: "finance-cas-server" }
+- "switch to batch-compute" → { sas: "batch-compute" }
+- "what's my current context" → { }
 
-Response Contract
-Returns a JSON object containing:
-- cas: The current/new CAS server name (string or null)
-- sas: The current/new SAS compute context name (string or null)
-- If no parameters provided, returns the current context values
-- If parameters provided, updates and returns the new context values
-- On error: error message if context cannot be set (e.g., invalid server name)
+NEGATIVE EXAMPLES (do not route here)
+- "read table cars" (use read-table)
+- "what's the value of X" (use get-env)
+- "run program" (use run-sas-program)
 
-Disambiguation & Clarification
-- If user says "switch servers" without specifying which: ask "Which server would you like to use: CAS, SAS, or both?"
-- If user provides a server name that may not exist: proceed with setting it (the backend will validate)
-- If user says "reset context": ask "Should I reset the CAS context, SAS context, or both?"
-- If user only says "context": ask "Would you like to check the current context or set a new one?"
-
-Examples (→ mapped params)
-- "Use the finance-cas-server" → { cas: "finance-cas-server" }
-- "Switch to SAS Studio Compute Context" → { sas: "SAS Studio Compute Context" }
-- "Set CAS to prod-cas and SAS to batch-compute" → { cas: "prod-cas", sas: "batch-compute" }
-- "What's my current context?" → { } (no parameters returns current context)
-- "Show me the active CAS server" → { } (no parameters returns current context)
-
-Negative Examples (should NOT call set-context)
-- "Read 10 rows from the customers table" (use read-table instead)
-- "What's the value of myVariable?" (use get-env instead)
-- "Run this SAS program" (use run-sas-program instead)
-
-Related Tools
-- get-env — to retrieve individual environment variable values
-- read-table — to read data using the current context
-- run-sas-program — to execute SAS programs in the current context
-- sas-query — to execute SQL queries in the current context
-`;
+ERRORS
+Returns current or updated context values {cas, sas}. Error if server not found or invalid name.
+  `;
   
     let spec = {
         name: 'set-context',

package/src/toolSet/tableInfo.js

@@ -9,77 +9,34 @@ import _tableInfo  from '../toolHelpers/_tableInfo.js';
 function tableInfo(_appContext) {
 
      let describe = `
-## table-info — retrieve metadata about a table in a CAS or SAS library
-
-LLM Invocation Guidance (When to use)
-Use THIS tool when:
-- User wants table structure/schema: "what columns are in the cars table?"
-- User wants column metadata: "describe the structure of customers table"
-- User wants to see data types: "show me the schema for sales table in Public"
-- User wants table statistics: "how many rows in the orders table?"
-- User wants column information: "what are the columns in the iris table?"
-
-Do NOT use this tool for:
-- Reading actual data rows (use read-table)
-- Listing tables in a library (use list-tables)
-- Checking if a table exists (use find-table)
-- Running queries (use sas-query)
-- Reading sample data (use read-table)
-
-Purpose
-Return metadata about a table in a specified library (caslib or libref). This includes column names, data types, labels, formats, and table-level statistics such as row count, file size, and timestamps.
-
-Parameters
-- table (string, required): The name of the table to inspect.
-- lib (string, required): The caslib or libref containing the table.
-- server (string, default 'cas'): Target server, either 'cas' or 'sas'. Defaults to 'cas' when omitted.
-
-Response Contract
-Returns a JSON object containing:
-- columns: Array of column objects with:
-  - name: Column name (string)
-  - type: Data type (string) - e.g., 'numeric', 'character'
-  - label: Column label if defined (string)
-  - format: Display format if defined (string)
-  - length: Column length for character fields (number)
-- tableInfo: Table-level metadata including:
-  - rowCount: Number of rows (number)
-  - fileSize: File size if available (number)
-  - created: Creation timestamp if available (string)
-  - modified: Last modified timestamp if available (string)
-- Empty object if table not found or accessible
-
-Disambiguation & Clarification
-- Missing library: ask "Which library contains the table you want to inspect?"
-- Missing table: ask "Which table would you like information about?"
-- If user wants data: clarify "Do you want the table structure (use table-info) or actual data rows (use read-table)?"
-- Ambiguous lib.table format: parse and use as separate parameters
-
-Examples (→ mapped params)
-- "describe table cars in sashelp" → { table: "cars", lib: "sashelp", server: "sas" }
-- "what columns are in orders from Public" → { table: "orders", lib: "Public", server: "cas" }
-- "show schema for sales in mylib" → { table: "sales", lib: "mylib", server: "cas" }
-- "table info for iris in Samples" → { table: "iris", lib: "Samples", server: "cas" }
-- "how many rows in customers on cas" → { table: "customers", lib: <lib>, server: "cas" }
-
-Negative Examples (should NOT call table-info)
-- "read 10 rows from cars" (use read-table instead)
-- "list tables in sashelp" (use list-tables instead)
-- "does table cars exist in Public?" (use find-table instead)
-- "run query on customers table" (use sas-query instead)
-- "show me data from the sales table" (use read-table instead)
-
-Usage Tips
-- Use this tool to inspect schema and column types before scoring or reading data.
-- After inspecting structure, use read-table to fetch actual data.
-- Combine with find-table to verify existence before inspection.
-
-Related Tools
-- find-table → table-info → read-table (typical workflow)
-- list-tables — to discover tables before inspecting
-- read-table — to fetch actual data after inspecting structure
-- find-table — to verify a table exists before inspection
-`;
+table-info — retrieve metadata about a table in a CAS or SAS library.
+
+USE when: what columns, describe structure, show schema, table statistics, column info
+DO NOT USE for: read data (use read-table), list tables (use list-tables), find table (use find-table), queries (use sas-query)
+
+PARAMETERS
+- table: string — table name (required)
+- lib: string — caslib or libref (required)
+- server: string (default: 'cas') — 'cas' or 'sas'
+
+ROUTING RULES
+- "what columns are in cars" → { table: "cars", lib: "<lib>", server: "cas" }
+- "describe table sales in Public" → { table: "sales", lib: "Public", server: "cas" }
+- "show schema for mylib.iris on sas" → { table: "iris", lib: "mylib", server: "sas" }
+
+EXAMPLES
+- "what columns in cars" → { table: "cars", lib: "<lib>", server: "cas" }
+- "describe structure of customers in Public" → { table: "customers", lib: "Public", server: "cas" }
+
+NEGATIVE EXAMPLES (do not route here)
+- "read table cars" (use read-table)
+- "list tables in Public" (use list-tables)
+- "does table exist" (use find-table)
+- "query table" (use sas-query)
+
+ERRORS
+Returns columns array (name, type, label, format, length) and tableInfo (rowCount, fileSize, created, modified).
+  `;
    
     let  specs = {
       name: 'table-info',

package/src/toolHelpers/getOpts.js

@@ -1,51 +0,0 @@
-/**
- * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * Helper function to get TLS options(for the app server) from specified directory
- * signed certificates 
- * for testing you can use mkcert
- * if this function return a null, coreehttp will create unsigned certs
- * @param {Object} _appContext - Application context containing SSLCERT property
- */
-
-import readCerts from './readCerts.js';
-function getOpts(_appContext) {
-
-    if (_appContext.tlsOpts != null) {
-        return _appContext.tlsOpts;
-    }
-    let r = readCerts(_appContext.SSLCERT);
-    _appContext.tlsOpts = r;
-    return r;
-
-
-    /*
-    let tlsdir = _appContext.SSLCERT;
-    if (tlsdir == null || tlsdir === 'NONE') {
-        return null;
-    }
-
-    console.error("[Note] Using TLS dir: " + tlsdir);
-    if (fs.existsSync(tlsdir) === false) {
-        console.error("[Warning] Specified TLS dir does not exist: " + tlsdir);
-        return null;
-    }
-
-    let listOfFiles = fs.readdirSync(tlsdir);
-    console.error("[Note] TLS/SSL files found: " + listOfFiles);
-    let options = {};
-    for(let i=0; i < listOfFiles.length; i++) {
-        let fname = listOfFiles[i];
-        let name = tlsdir + '/' + listOfFiles[i];
-        let key = fname.split('.')[0];
-        options[key] = fs.readFileSync(name, { encoding: 'utf8' });
-    }
-    console.error('TLS FILES', Object.keys(options));
-    _appContext.tlsOpts = options;
-    return options;
-    */
-
-}
-export default getOpts;

package/src/toolHelpers/getOptsViya.js

@@ -1,44 +0,0 @@
-/**
- * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-import readCerts from './readCerts.js';
-function getOptsViya(_appContext) {
-
-    if (_appContext.contexts.viyaCert != null) {
-        console.error('[Note] Using cached viyaOpts');
-        return _appContext.contexts.viyaCert;
-    }
-    let r = readCerts(_appContext.VIYACERT);
-    _appContext.contexts.viyaCert = r;
-    return r;
-
-    /*
-    let tlsdir = _appContext.VIYACERT;
-    if (tlsdir == null || tlsdir === 'NONE') {
-        return {};
-    }
-
-    console.error(`[Note] Using VIYACERT dir: ` + tlsdir);
-    if (fs.existsSync(tlsdir) === false) {
-        console.error("[Warning] Specified VIYACERT dir does not exist: " + tlsdir);
-        return {};
-    }
-
-    let listOfFiles = fs.readdirSync(tlsdir);
-    console.error("[Note] TLS/SSL files found: " + listOfFiles);
-    let options = {};
-    for(let i=0; i < listOfFiles.length; i++) {
-        let fname = listOfFiles[i];
-        let name = tlsdir + '/' + listOfFiles[i];
-        let key = fname.split('.')[0];
-        console.error('Reading TLS file: ' + name + ' as key: ' + key);
-        options[key] = fs.readFileSync(name, { encoding: 'utf8' });
-    }
-    console.error('VIYACERT FILES', Object.keys(options));
-    _appContext.contexts.viyaCert = options;
-    return options;
-    */
-
-}
-export default getOptsViya;