@mcp-s/cli 0.0.9 → 0.0.11

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { appendFileSync, mkdirSync as mkdirSync5 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join7 } from "path";
+import { appendFileSync, mkdirSync as mkdirSync6 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join8 } from "path";
 
 // src/client.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -60,7 +60,7 @@ async function saveAuthData() {
       mode: 384
     });
   } catch (err) {
-    if (process.env.MCP_DEBUG) {
+    if (process.env.MCP_S_CLI_DEBUG) {
       console.error(
         `[mcp-s-cli] Failed to save auth data: ${err.message}`
       );
@@ -190,7 +190,7 @@ async function exchangeAuthorizationCode(tokenEndpoint, clientId, code, codeVeri
 }
 async function startCallbackServer(port) {
   const http = await import("http");
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const server = http.createServer((req, res) => {
       const url = new URL(req.url ?? "/", `http://localhost:${port}`);
       const code = url.searchParams.get("code");
@@ -221,7 +221,7 @@ async function startCallbackServer(port) {
           </html>
         `);
         server.close();
-        resolve4(code);
+        resolve5(code);
         return;
       }
       res.writeHead(400, { "Content-Type": "text/html" });
@@ -583,51 +583,35 @@ var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_RETRY_DELAY_MS = 1e3;
 var DEFAULT_DAEMON_TIMEOUT_SECONDS = 300;
 function debug(message) {
-  if (process.env.MCP_DEBUG) {
+  if (process.env.MCP_S_CLI_DEBUG) {
     console.error(`[mcp-s-cli] ${message}`);
   }
 }
-function getTimeoutMs() {
-  const envTimeout = process.env.MCP_TIMEOUT;
-  if (envTimeout) {
-    const seconds = Number.parseInt(envTimeout, 10);
-    if (!Number.isNaN(seconds) && seconds > 0) {
-      return seconds * 1e3;
-    }
+function getTimeoutMs(settings) {
+  if (settings?.timeout != null && settings.timeout > 0) {
+    return settings.timeout * 1e3;
   }
   return DEFAULT_TIMEOUT_MS;
 }
-function getMaxRetries() {
-  const envRetries = process.env.MCP_MAX_RETRIES;
-  if (envRetries) {
-    const retries = Number.parseInt(envRetries, 10);
-    if (!Number.isNaN(retries) && retries >= 0) {
-      return retries;
-    }
+function getMaxRetries(settings) {
+  if (settings?.maxRetries != null && settings.maxRetries >= 0) {
+    return settings.maxRetries;
   }
   return DEFAULT_MAX_RETRIES;
 }
-function getRetryDelayMs() {
-  const envDelay = process.env.MCP_RETRY_DELAY;
-  if (envDelay) {
-    const delay = Number.parseInt(envDelay, 10);
-    if (!Number.isNaN(delay) && delay > 0) {
-      return delay;
-    }
+function getRetryDelayMs(settings) {
+  if (settings?.retryDelay != null && settings.retryDelay > 0) {
+    return settings.retryDelay;
   }
   return DEFAULT_RETRY_DELAY_MS;
 }
 var DAEMON_SERVER_NAME = "mcp-s-cli";
-function isDaemonEnabled() {
-  return process.env.MCP_DAEMON !== "0";
+function isDaemonEnabled(settings) {
+  return settings?.daemon !== false;
 }
-function getDaemonTimeoutMs() {
-  const envTimeout = process.env.MCP_DAEMON_TIMEOUT;
-  if (envTimeout) {
-    const seconds = Number.parseInt(envTimeout, 10);
-    if (!Number.isNaN(seconds) && seconds > 0) {
-      return seconds * 1e3;
-    }
+function getDaemonTimeoutMs(settings) {
+  if (settings?.daemonTimeout != null && settings.daemonTimeout > 0) {
+    return settings.daemonTimeout * 1e3;
   }
   return DEFAULT_DAEMON_TIMEOUT_SECONDS * 1e3;
 }
@@ -650,7 +634,7 @@ function getConfigHash(config) {
   return createHash("sha256").update(str).digest("hex").slice(0, 16);
 }
 function isStrictEnvMode() {
-  const value = process.env.MCP_STRICT_ENV?.toLowerCase();
+  const value = process.env.MCP_S_CLI_STRICT_ENV?.toLowerCase();
   return value !== "false" && value !== "0";
 }
 function substituteEnvVars(value) {
@@ -673,7 +657,7 @@ function substituteEnvVars(value) {
           type: "MISSING_ENV_VAR",
           message,
           details: "Referenced in config but not set in environment",
-          suggestion: `Set the variable(s) before running: export ${missingVars[0]}="value" or set MCP_STRICT_ENV=false to use empty values`
+          suggestion: `Set the variable(s) before running: export ${missingVars[0]}="value" or set MCP_S_CLI_STRICT_ENV=false to use empty values`
         })
       );
     }
@@ -748,8 +732,8 @@ async function loadConfig(explicitPath) {
   let configPath;
   if (explicitPath) {
     configPath = resolve(explicitPath);
-  } else if (process.env.MCP_CONFIG_PATH) {
-    configPath = resolve(process.env.MCP_CONFIG_PATH);
+  } else if (process.env.MCP_S_CLI_CONFIG_PATH) {
+    configPath = resolve(process.env.MCP_S_CLI_CONFIG_PATH);
   }
   if (configPath) {
     if (!existsSync(configPath)) {
@@ -780,6 +764,7 @@ async function loadConfig(explicitPath) {
     throw new Error(formatCliError(configMissingFieldError(configPath)));
   }
   const knownFields = [
+    "enabled",
     "org",
     "baseUrl",
     "mcp",
@@ -787,7 +772,8 @@ async function loadConfig(explicitPath) {
     "userAccessKey",
     "token",
     "allowedTools",
-    "disabledTools"
+    "disabledTools",
+    "settings"
   ];
   const hasKnownField = knownFields.some((f) => f in raw);
   if (!hasKnownField) {
@@ -795,7 +781,7 @@ async function loadConfig(explicitPath) {
   }
   raw = substituteEnvVarsInObject(raw);
   const serverConfig = deriveServerConfig(raw);
-  return { raw, serverConfig };
+  return { raw, serverConfig, settings: raw.settings ?? {} };
 }
 
 // src/daemon-client.ts
@@ -883,10 +869,10 @@ function killProcess(pid) {
     return false;
   }
 }
-async function runDaemon(serverName, config) {
+async function runDaemon(serverName, config, settings) {
   const socketPath = getSocketPath();
   const configHash = getConfigHash(config);
-  const timeoutMs = getDaemonTimeoutMs();
+  const timeoutMs = getDaemonTimeoutMs(settings);
   let idleTimer = null;
   let mcpClient = null;
   let server = null;
@@ -1032,7 +1018,7 @@ async function runDaemon(serverName, config) {
       };
     }
   };
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     server = createServer((socket) => {
       activeConnections.add(socket);
       debug(`[daemon:${serverName}] Client connected`);
@@ -1064,7 +1050,7 @@ async function runDaemon(serverName, config) {
       writeFileSync(getReadyPath(), String(process.pid), {
         mode: 384
       });
-      resolve4();
+      resolve5();
     });
   }).catch(async (error) => {
     console.error(
@@ -1078,8 +1064,11 @@ async function runDaemon(serverName, config) {
 if (process.argv[2] === "--daemon") {
   const serverName = process.argv[3];
   const configJson = process.argv[4];
+  const settingsJson = process.argv[5];
   if (!serverName || !configJson) {
-    console.error("Usage: daemon.ts --daemon <serverName> <configJson>");
+    console.error(
+      "Usage: daemon.ts --daemon <serverName> <configJson> [settingsJson]"
+    );
     process.exit(1);
   }
   let config;
@@ -1089,7 +1078,16 @@ if (process.argv[2] === "--daemon") {
     console.error("Invalid config JSON");
     process.exit(1);
   }
-  runDaemon(serverName, config).catch((error) => {
+  let settings;
+  if (settingsJson) {
+    try {
+      settings = JSON.parse(settingsJson);
+    } catch {
+      console.error("Invalid settings JSON");
+      process.exit(1);
+    }
+  }
+  runDaemon(serverName, config, settings).catch((error) => {
     console.error("Daemon failed:", error);
     process.exit(1);
   });
@@ -1100,7 +1098,7 @@ function generateRequestId() {
   return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
 }
 async function sendRequest(socketPath, request) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const socket = createConnection(socketPath);
     let settled = false;
     const settle = (fn) => {
@@ -1128,7 +1126,7 @@ async function sendRequest(socketPath, request) {
         const response = JSON.parse(line);
         clearTimeout(timer);
         socket.end();
-        settle(() => resolve4(response));
+        settle(() => resolve5(response));
       } catch {
         clearTimeout(timer);
         socket.end();
@@ -1175,17 +1173,18 @@ function isDaemonValid(serverName, config) {
   }
   return true;
 }
-async function spawnDaemon(serverName, config) {
+async function spawnDaemon(serverName, config, settings) {
   debug(`[daemon-client] Spawning daemon for ${serverName}`);
   const __dirname = join2(fileURLToPath(import.meta.url), "..");
   const daemonScript = join2(__dirname, "daemon.js");
   const configJson = JSON.stringify(config);
+  const settingsJson = JSON.stringify(settings ?? {});
   const proc = spawn(
     "node",
-    [daemonScript, "--daemon", serverName, configJson],
+    [daemonScript, "--daemon", serverName, configJson, settingsJson],
     {
       stdio: "ignore",
-      env: { ...process.env, MCP_NO_OAUTH: "1" },
+      env: { ...process.env, MCP_S_CLI_NO_OAUTH: "1" },
       detached: true
     }
   );
@@ -1208,10 +1207,10 @@ async function spawnDaemon(serverName, config) {
   debug(`[daemon-client] Daemon spawn timeout for ${serverName}`);
   return false;
 }
-async function getDaemonConnection(serverName, config) {
+async function getDaemonConnection(serverName, config, settings) {
   const socketPath = getSocketPath();
   if (!isDaemonValid(serverName, config)) {
-    const spawned = await spawnDaemon(serverName, config);
+    const spawned = await spawnDaemon(serverName, config, settings);
     if (!spawned) {
       debug(`[daemon-client] Failed to spawn daemon for ${serverName}`);
       return null;
@@ -1299,13 +1298,13 @@ async function cleanupOrphanedDaemons() {
 }
 
 // src/version.ts
-var VERSION = "0.0.9";
+var VERSION = "0.0.11";
 
 // src/client.ts
-function getRetryConfig() {
-  const totalBudgetMs = getTimeoutMs();
-  const maxRetries = getMaxRetries();
-  const baseDelayMs = getRetryDelayMs();
+function getRetryConfig(settings) {
+  const totalBudgetMs = getTimeoutMs(settings);
+  const maxRetries = getMaxRetries(settings);
+  const baseDelayMs = getRetryDelayMs(settings);
   const retryBudgetMs = Math.max(0, totalBudgetMs - 5e3);
   return {
     maxRetries,
@@ -1351,7 +1350,7 @@ function calculateDelay(attempt, config) {
   return Math.round(cappedDelay + jitter);
 }
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 async function withRetry(fn, operationName, config = getRetryConfig()) {
   let lastError;
@@ -1443,7 +1442,7 @@ ${stderrOutput}`;
   }, `connect to ${serverName}`);
 }
 async function connectToHttpServer(serverName, config) {
-  const oauthEnabled = process.env.MCP_NO_OAUTH !== "1";
+  const oauthEnabled = process.env.MCP_S_CLI_NO_OAUTH !== "1";
   return withRetry(async () => {
     const configuredAuth = config.headers?.Authorization || config.headers?.authorization;
     let headers = { ...config.headers };
@@ -1593,24 +1592,32 @@ async function listTools(client) {
     }));
   }, "list tools");
 }
-async function callTool(client, toolName, args) {
-  return withRetry(async () => {
-    const result = await client.callTool(
-      {
-        name: toolName,
-        arguments: args
-      },
-      void 0,
-      { timeout: getTimeoutMs() }
-    );
-    return result;
-  }, `call tool ${toolName}`);
+async function callTool(client, toolName, args, settings) {
+  return withRetry(
+    async () => {
+      const result = await client.callTool(
+        {
+          name: toolName,
+          arguments: args
+        },
+        void 0,
+        { timeout: getTimeoutMs(settings) }
+      );
+      return result;
+    },
+    `call tool ${toolName}`,
+    getRetryConfig(settings)
+  );
 }
-async function getConnection(serverName, config) {
+async function getConnection(serverName, config, settings) {
   await cleanupOrphanedDaemons();
-  if (isDaemonEnabled()) {
+  if (isDaemonEnabled(settings)) {
     try {
-      const daemonConn = await getDaemonConnection(serverName, config);
+      const daemonConn = await getDaemonConnection(
+        serverName,
+        config,
+        settings
+      );
       if (daemonConn) {
         debug(`Using daemon connection for ${serverName}`);
         return {
@@ -1653,7 +1660,7 @@ async function getConnection(serverName, config) {
       if (!isToolAllowed(toolName, config)) {
         throw new Error(`Tool "${toolName}" is disabled by configuration`);
       }
-      return callTool(client, toolName, args);
+      return callTool(client, toolName, args, settings);
     },
     async getInstructions() {
       return client.getInstructions();
@@ -1794,12 +1801,12 @@ function formatToolResult(result) {
 }
 
 // src/commands/call.ts
-async function parseArgs(argsString) {
+async function parseArgs(argsString, settings) {
   let jsonString;
   if (argsString) {
     jsonString = argsString;
   } else if (!process.stdin.isTTY) {
-    const timeoutMs = getTimeoutMs();
+    const timeoutMs = getTimeoutMs(settings);
     const chunks = [];
     let timeoutId;
     const readPromise = (async () => {
@@ -1841,11 +1848,11 @@ async function callCommand(options) {
     console.error(error.message);
     process.exit(1 /* CLIENT_ERROR */);
   }
-  const { serverConfig } = loaded;
+  const { serverConfig, settings } = loaded;
   const serverLabel = "server";
   if (options.args !== void 0) {
     try {
-      await parseArgs(options.args);
+      await parseArgs(options.args, settings);
     } catch (error) {
       console.error(error.message);
       process.exit(1 /* CLIENT_ERROR */);
@@ -1853,14 +1860,14 @@ async function callCommand(options) {
   }
   let args;
   try {
-    args = await parseArgs(options.args);
+    args = await parseArgs(options.args, settings);
   } catch (error) {
     console.error(error.message);
     process.exit(1 /* CLIENT_ERROR */);
   }
   let connection;
   try {
-    connection = await getConnection(serverLabel, serverConfig);
+    connection = await getConnection(serverLabel, serverConfig, settings);
   } catch (error) {
     console.error(
       formatCliError(
@@ -1934,6 +1941,247 @@ function clearHistoryCommand() {
   console.log(`Cleared history from ${HISTORY_PATH}`);
 }
 
+// src/commands/config.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname3, join as join4, resolve as resolve2 } from "path";
+var TOP_LEVEL_KEYS = [
+  "enabled",
+  "org",
+  "baseUrl",
+  "mcp",
+  "toolkit",
+  "userAccessKey",
+  "token",
+  "allowedTools",
+  "disabledTools",
+  "settings"
+];
+var SETTINGS_KEYS = [
+  "settings.timeout",
+  "settings.maxRetries",
+  "settings.retryDelay",
+  "settings.daemon",
+  "settings.daemonTimeout",
+  "settings.history"
+];
+var ALL_KNOWN_KEYS = [...TOP_LEVEL_KEYS, ...SETTINGS_KEYS];
+function getDefaultConfigPath() {
+  return join4(homedir3(), ".config", "mcp-s-cli", "config.json");
+}
+function resolveConfigPath(explicitPath) {
+  if (explicitPath) return resolve2(explicitPath);
+  if (process.env.MCP_S_CLI_CONFIG_PATH)
+    return resolve2(process.env.MCP_S_CLI_CONFIG_PATH);
+  return getDefaultConfigPath();
+}
+function readConfigFile(configPath) {
+  if (!existsSync5(configPath)) return {};
+  const content = readFileSync3(configPath, "utf-8").trim();
+  if (!content) return {};
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    console.error(
+      formatCliError({
+        code: 1 /* CLIENT_ERROR */,
+        type: "CONFIG_INVALID_JSON",
+        message: `Cannot parse config file: ${configPath}`,
+        suggestion: "Fix or delete the file, then run mcp-s-cli init"
+      })
+    );
+    process.exit(1 /* CLIENT_ERROR */);
+  }
+}
+function writeConfigFile(configPath, config) {
+  mkdirSync3(dirname3(configPath), { recursive: true });
+  writeFileSync3(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+}
+function parseValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  const n = Number(raw);
+  if (!Number.isNaN(n) && raw.trim() !== "") return n;
+  return raw;
+}
+function setNestedKey(obj, parts, value) {
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0 || current[part] === null || typeof current[part] !== "object" || Array.isArray(current[part])) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function getNestedKey(obj, parts) {
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function validateKey(key) {
+  const known = ALL_KNOWN_KEYS;
+  if (!known.includes(key)) {
+    console.error(
+      formatCliError({
+        code: 1 /* CLIENT_ERROR */,
+        type: "UNKNOWN_CONFIG_KEY",
+        message: `Unknown config key: "${key}"`,
+        details: `Known keys: ${ALL_KNOWN_KEYS.join(", ")}`,
+        suggestion: "Use dot-notation for nested keys, e.g. settings.timeout, settings.daemon"
+      })
+    );
+    process.exit(1 /* CLIENT_ERROR */);
+  }
+}
+function configSetCommand(opts) {
+  const { key, value, configPath: explicitPath } = opts;
+  validateKey(key);
+  const configPath = resolveConfigPath(explicitPath);
+  const config = readConfigFile(configPath);
+  const parts = key.split(".");
+  const parsed = parseValue(value);
+  setNestedKey(config, parts, parsed);
+  writeConfigFile(configPath, config);
+  console.log(`Set ${key} = ${JSON.stringify(parsed)} in ${configPath}`);
+}
+function configGetCommand(opts) {
+  const { key, configPath: explicitPath } = opts;
+  validateKey(key);
+  const configPath = resolveConfigPath(explicitPath);
+  if (!existsSync5(configPath)) {
+    console.error(
+      formatCliError({
+        code: 1 /* CLIENT_ERROR */,
+        type: "CONFIG_NOT_FOUND",
+        message: `Config file not found: ${configPath}`,
+        suggestion: "Run mcp-s-cli init or mcp-s-cli config set <key> <value>"
+      })
+    );
+    process.exit(1 /* CLIENT_ERROR */);
+  }
+  const config = readConfigFile(configPath);
+  const parts = key.split(".");
+  const value = getNestedKey(config, parts);
+  if (value === void 0) {
+    console.error(
+      formatCliError({
+        code: 1 /* CLIENT_ERROR */,
+        type: "CONFIG_KEY_NOT_SET",
+        message: `Key "${key}" is not set in ${configPath}`,
+        suggestion: `Set it with: mcp-s-cli config set ${key} <value>`
+      })
+    );
+    process.exit(1 /* CLIENT_ERROR */);
+  }
+  console.log(JSON.stringify(value));
+}
+function configShowCommand(opts) {
+  const configPath = resolveConfigPath(opts.configPath);
+  if (!existsSync5(configPath)) {
+    console.error(
+      formatCliError({
+        code: 1 /* CLIENT_ERROR */,
+        type: "CONFIG_NOT_FOUND",
+        message: `Config file not found: ${configPath}`,
+        suggestion: "Run mcp-s-cli init or mcp-s-cli config set <key> <value>"
+      })
+    );
+    process.exit(1 /* CLIENT_ERROR */);
+  }
+  const config = readConfigFile(configPath);
+  console.log(JSON.stringify(config, null, 2));
+}
+function printConfigHelp() {
+  console.log(`
+mcp-s-cli config - Read and write config.json settings
+
+Usage:
+  mcp-s-cli config set <key> <value>   Set a config value
+  mcp-s-cli config get <key>           Print a single config value
+  mcp-s-cli config show                Print the full config as JSON
+
+Keys (dot-notation for nested values):
+
+  General
+    enabled               boolean  Whether mcp-s-cli is enabled            (default: true)
+
+  Connection
+    org                   string   Org name \u2014 derives URL as https://<org>.mcp-s.com/mcp
+    baseUrl               string   Custom server base URL (used when org is not set)
+    mcp                   string   MCP identifier sent as x-mcp header
+    toolkit               string   Toolkit name sent as x-toolkit header
+    token                 string   Static Bearer token for HTTP auth
+    userAccessKey         string   User access key \u2014 triggers stdio mode when present
+
+  Tool filtering
+    allowedTools          array    Glob patterns for tools to allow (JSON array)
+    disabledTools         array    Glob patterns to exclude (takes precedence over allowedTools)
+
+  Behaviour  (settings.*)
+    settings.timeout      number   Request timeout in seconds          (default: 1800)
+    settings.maxRetries   number   Max retry attempts; 0 = disable     (default: 3)
+    settings.retryDelay   number   Base retry delay in milliseconds     (default: 1000)
+    settings.daemon       boolean  Enable daemon connection caching     (default: true)
+    settings.daemonTimeout number  Daemon idle timeout in seconds       (default: 300)
+    settings.history      boolean  Append invocations to history.jsonl  (default: false)
+
+Examples:
+  mcp-s-cli config set org my-org
+  mcp-s-cli config set settings.timeout 30
+  mcp-s-cli config set settings.daemon false
+  mcp-s-cli config get settings.timeout
+  mcp-s-cli config show
+`);
+}
+function configCommand(opts) {
+  switch (opts.subcommand) {
+    case "set": {
+      if (!opts.key) {
+        console.error(
+          formatCliError(missingArgumentError("config set", "key"))
+        );
+        process.exit(1 /* CLIENT_ERROR */);
+      }
+      if (opts.value === void 0) {
+        console.error(
+          formatCliError(missingArgumentError("config set", "value"))
+        );
+        process.exit(1 /* CLIENT_ERROR */);
+      }
+      configSetCommand({
+        key: opts.key,
+        value: opts.value,
+        configPath: opts.configPath
+      });
+      break;
+    }
+    case "get": {
+      if (!opts.key) {
+        console.error(
+          formatCliError(missingArgumentError("config get", "key"))
+        );
+        process.exit(1 /* CLIENT_ERROR */);
+      }
+      configGetCommand({ key: opts.key, configPath: opts.configPath });
+      break;
+    }
+    case "show": {
+      configShowCommand({ configPath: opts.configPath });
+      break;
+    }
+  }
+}
+
 // src/commands/grep.ts
 function globToRegex(pattern) {
   let escaped = "";
@@ -1970,7 +2218,7 @@ async function grepCommand(options) {
     console.error(error.message);
     process.exit(1 /* CLIENT_ERROR */);
   }
-  const { serverConfig } = loaded;
+  const { serverConfig, settings } = loaded;
   const serverLabel = "server";
   const pattern = globToRegex(options.pattern);
   debug(`Searching for pattern "${options.pattern}"`);
@@ -1978,7 +2226,7 @@ async function grepCommand(options) {
   const allResults = [];
   let searchError;
   try {
-    connection = await getConnection(serverLabel, serverConfig);
+    connection = await getConnection(serverLabel, serverConfig, settings);
     const tools = await connection.listTools();
     for (const tool of tools) {
       if (pattern.test(tool.name)) {
@@ -2016,11 +2264,11 @@ async function infoCommand(options) {
     console.error(error.message);
     process.exit(1 /* CLIENT_ERROR */);
   }
-  const { serverConfig } = loaded;
+  const { serverConfig, settings } = loaded;
   const serverLabel = "server";
   let connection;
   try {
-    connection = await getConnection(serverLabel, serverConfig);
+    connection = await getConnection(serverLabel, serverConfig, settings);
   } catch (error) {
     console.error(
       formatCliError(
@@ -2062,97 +2310,97 @@ async function infoCommand(options) {
 }
 
 // src/commands/init.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname4, join as join5 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname5, join as join6 } from "path";
 import * as readline from "readline";
 
 // src/commands/install-skill.ts
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   lstatSync,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync3,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync4,
   readlinkSync,
   rmSync as rmSync2,
   symlinkSync,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
-import { homedir as homedir3, platform } from "os";
-import { dirname as dirname3, join as join4, normalize, relative, resolve as resolve2, sep } from "path";
+import { homedir as homedir4, platform } from "os";
+import { dirname as dirname4, join as join5, normalize, relative, resolve as resolve3, sep } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var home = homedir3();
+var home = homedir4();
 var AGENTS = {
   cursor: {
     displayName: "Cursor",
-    globalSkillsDir: join4(home, ".cursor", "skills"),
-    detect: () => existsSync5(join4(home, ".cursor"))
+    globalSkillsDir: join5(home, ".cursor", "skills"),
+    detect: () => existsSync6(join5(home, ".cursor"))
   },
   codex: {
     displayName: "Codex",
-    globalSkillsDir: join4(
-      process.env.CODEX_HOME?.trim() || join4(home, ".codex"),
+    globalSkillsDir: join5(
+      process.env.CODEX_HOME?.trim() || join5(home, ".codex"),
       "skills"
     ),
-    detect: () => existsSync5(process.env.CODEX_HOME?.trim() || join4(home, ".codex")) || existsSync5("/etc/codex")
+    detect: () => existsSync6(process.env.CODEX_HOME?.trim() || join5(home, ".codex")) || existsSync6("/etc/codex")
   },
   "claude-code": {
     displayName: "Claude Code",
-    globalSkillsDir: join4(
-      process.env.CLAUDE_CONFIG_DIR?.trim() || join4(home, ".claude"),
+    globalSkillsDir: join5(
+      process.env.CLAUDE_CONFIG_DIR?.trim() || join5(home, ".claude"),
       "skills"
     ),
-    detect: () => existsSync5(
-      process.env.CLAUDE_CONFIG_DIR?.trim() || join4(home, ".claude")
+    detect: () => existsSync6(
+      process.env.CLAUDE_CONFIG_DIR?.trim() || join5(home, ".claude")
     )
   },
   windsurf: {
     displayName: "Windsurf",
-    globalSkillsDir: join4(home, ".codeium", "windsurf", "skills"),
-    detect: () => existsSync5(join4(home, ".codeium", "windsurf"))
+    globalSkillsDir: join5(home, ".codeium", "windsurf", "skills"),
+    detect: () => existsSync6(join5(home, ".codeium", "windsurf"))
   },
   "github-copilot": {
     displayName: "GitHub Copilot",
-    globalSkillsDir: join4(home, ".copilot", "skills"),
-    detect: () => existsSync5(join4(home, ".copilot"))
+    globalSkillsDir: join5(home, ".copilot", "skills"),
+    detect: () => existsSync6(join5(home, ".copilot"))
   },
   cline: {
     displayName: "Cline",
-    globalSkillsDir: join4(home, ".cline", "skills"),
-    detect: () => existsSync5(join4(home, ".cline"))
+    globalSkillsDir: join5(home, ".cline", "skills"),
+    detect: () => existsSync6(join5(home, ".cline"))
   },
   roo: {
     displayName: "Roo Code",
-    globalSkillsDir: join4(home, ".roo", "skills"),
-    detect: () => existsSync5(join4(home, ".roo"))
+    globalSkillsDir: join5(home, ".roo", "skills"),
+    detect: () => existsSync6(join5(home, ".roo"))
   },
   continue: {
     displayName: "Continue",
-    globalSkillsDir: join4(home, ".continue", "skills"),
-    detect: () => existsSync5(join4(home, ".continue")) || existsSync5(join4(process.cwd(), ".continue"))
+    globalSkillsDir: join5(home, ".continue", "skills"),
+    detect: () => existsSync6(join5(home, ".continue")) || existsSync6(join5(process.cwd(), ".continue"))
   }
 };
 function getCanonicalSkillDir(skillName) {
-  return join4(home, ".agents", "skills", skillName);
+  return join5(home, ".agents", "skills", skillName);
 }
 function getCanonicalSkillPath() {
   return getCanonicalSkillDir(SKILL_NAME);
 }
 function isPathSafe(base, target) {
-  const normalizedBase = normalize(resolve2(base));
-  const normalizedTarget = normalize(resolve2(target));
+  const normalizedBase = normalize(resolve3(base));
+  const normalizedTarget = normalize(resolve3(target));
   return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
 }
 function createSymlinkSync(target, linkPath) {
   try {
-    const resolvedTarget = resolve2(target);
-    const resolvedLinkPath = resolve2(linkPath);
+    const resolvedTarget = resolve3(target);
+    const resolvedLinkPath = resolve3(linkPath);
     if (resolvedTarget === resolvedLinkPath) return true;
     try {
       const stats = lstatSync(linkPath);
       if (stats.isSymbolicLink()) {
         const existing = readlinkSync(linkPath);
-        const resolvedExisting = resolve2(dirname3(linkPath), existing);
+        const resolvedExisting = resolve3(dirname4(linkPath), existing);
         if (resolvedExisting === resolvedTarget) return true;
         rmSync2(linkPath);
       } else {
@@ -2166,8 +2414,8 @@ function createSymlinkSync(target, linkPath) {
         }
       }
     }
-    const linkDir = dirname3(linkPath);
-    mkdirSync3(linkDir, { recursive: true });
+    const linkDir = dirname4(linkPath);
+    mkdirSync4(linkDir, { recursive: true });
     const relativePath = relative(linkDir, target);
     symlinkSync(
       relativePath,
@@ -2182,15 +2430,15 @@ function createSymlinkSync(target, linkPath) {
 var SKILL_NAME = "mcp-s-cli";
 function getSkillMdContent() {
   const __filename = fileURLToPath2(import.meta.url);
-  const __dirname = dirname3(__filename);
+  const __dirname = dirname4(__filename);
   const candidates = [
-    join4(__dirname, "SKILL.md"),
-    join4(__dirname, "..", "SKILL.md"),
-    join4(__dirname, "..", "..", "SKILL.md")
+    join5(__dirname, "SKILL.md"),
+    join5(__dirname, "..", "SKILL.md"),
+    join5(__dirname, "..", "..", "SKILL.md")
   ];
   for (const candidate of candidates) {
-    if (existsSync5(candidate)) {
-      return readFileSync3(candidate, "utf-8");
+    if (existsSync6(candidate)) {
+      return readFileSync4(candidate, "utf-8");
     }
   }
   throw new Error(
@@ -2200,12 +2448,12 @@ function getSkillMdContent() {
 function installSkill() {
   const content = getSkillMdContent();
   const canonicalDir = getCanonicalSkillDir(SKILL_NAME);
-  if (!isPathSafe(join4(home, ".agents", "skills"), canonicalDir)) {
+  if (!isPathSafe(join5(home, ".agents", "skills"), canonicalDir)) {
     throw new Error("Invalid skill name: potential path traversal detected");
   }
   rmSync2(canonicalDir, { recursive: true, force: true });
-  mkdirSync3(canonicalDir, { recursive: true });
-  writeFileSync3(join4(canonicalDir, "SKILL.md"), content, "utf-8");
+  mkdirSync4(canonicalDir, { recursive: true });
+  writeFileSync4(join5(canonicalDir, "SKILL.md"), content, "utf-8");
   const result = {
     installed: [],
     skipped: [],
@@ -2217,7 +2465,7 @@ function installSkill() {
       result.skipped.push(agentName);
       continue;
     }
-    const agentSkillDir = join4(agent.globalSkillsDir, SKILL_NAME);
+    const agentSkillDir = join5(agent.globalSkillsDir, SKILL_NAME);
     if (!isPathSafe(agent.globalSkillsDir, agentSkillDir)) {
       result.failed.push({
         agent: agentName,
@@ -2229,8 +2477,8 @@ function installSkill() {
       const symlinkOk = createSymlinkSync(canonicalDir, agentSkillDir);
       if (!symlinkOk) {
         rmSync2(agentSkillDir, { recursive: true, force: true });
-        mkdirSync3(agentSkillDir, { recursive: true });
-        writeFileSync3(join4(agentSkillDir, "SKILL.md"), content, "utf-8");
+        mkdirSync4(agentSkillDir, { recursive: true });
+        writeFileSync4(join5(agentSkillDir, "SKILL.md"), content, "utf-8");
       }
       result.installed.push(agentName);
     } catch (err) {
@@ -2250,8 +2498,8 @@ function clearSkill() {
     canonicalRemoved: false
   };
   for (const [agentName, agent] of Object.entries(AGENTS)) {
-    const agentSkillDir = join4(agent.globalSkillsDir, SKILL_NAME);
-    if (!existsSync5(agentSkillDir)) {
+    const agentSkillDir = join5(agent.globalSkillsDir, SKILL_NAME);
+    if (!existsSync6(agentSkillDir)) {
       result.skipped.push(agentName);
       continue;
     }
@@ -2266,7 +2514,7 @@ function clearSkill() {
     }
   }
   const canonicalDir = getCanonicalSkillDir(SKILL_NAME);
-  if (existsSync5(canonicalDir)) {
+  if (existsSync6(canonicalDir)) {
     try {
       rmSync2(canonicalDir, { recursive: true, force: true });
       result.canonicalRemoved = true;
@@ -2277,12 +2525,12 @@ function clearSkill() {
 }
 function getSkillInstallInfo() {
   return Object.entries(AGENTS).filter(([, agent]) => agent.detect()).map(([agentName, agent]) => {
-    const agentSkillDir = join4(agent.globalSkillsDir, SKILL_NAME);
+    const agentSkillDir = join5(agent.globalSkillsDir, SKILL_NAME);
     return {
       agent: agentName,
       displayName: agent.displayName,
       path: agentSkillDir,
-      installed: existsSync5(join4(agentSkillDir, "SKILL.md"))
+      installed: existsSync6(join5(agentSkillDir, "SKILL.md"))
     };
   });
 }
@@ -2352,7 +2600,7 @@ function cancel(msg) {
 `);
 }
 function readLine(prompt) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
@@ -2361,16 +2609,16 @@ function readLine(prompt) {
     process.stdout.write(prompt);
     rl.once("line", (line) => {
       rl.close();
-      resolve4(line);
+      resolve5(line);
     });
     rl.once("SIGINT", () => {
       rl.close();
       process.stdout.write("\n");
-      resolve4(CANCEL);
+      resolve5(CANCEL);
     });
     process.stdin.once("end", () => {
       rl.close();
-      resolve4(CANCEL);
+      resolve5(CANCEL);
     });
   });
 }
@@ -2403,14 +2651,14 @@ async function select(opts) {
 `);
       });
     };
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       readline.emitKeypressEvents(process.stdin);
       process.stdin.setRawMode(true);
       process.stdin.resume();
       const onKey = (_, key) => {
         if (key.ctrl && key.name === "c") {
           cleanup();
-          resolve4(CANCEL);
+          resolve5(CANCEL);
           return;
         }
         if (key.name === "up") {
@@ -2423,7 +2671,7 @@ async function select(opts) {
         }
         if (key.name === "return") {
           cleanup();
-          resolve4(options[idx].value);
+          resolve5(options[idx].value);
         }
       };
       const cleanup = () => {
@@ -2474,15 +2722,24 @@ ${BAR}  ${c(A.cyan, "\u25C6")} `
   }
 }
 var p = { intro, outro, cancel, isCancel, select, text };
-var GLOBAL_CONFIG_PATH2 = join5(
-  homedir4(),
+var GLOBAL_CONFIG_PATH2 = join6(
+  homedir5(),
   ".config",
   "mcp-s-cli",
   "config.json"
 );
+function readExistingConfig() {
+  try {
+    if (existsSync7(GLOBAL_CONFIG_PATH2)) {
+      return JSON.parse(readFileSync5(GLOBAL_CONFIG_PATH2, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
 function writeConfig(config) {
-  mkdirSync4(dirname4(GLOBAL_CONFIG_PATH2), { recursive: true });
-  writeFileSync4(
+  mkdirSync5(dirname5(GLOBAL_CONFIG_PATH2), { recursive: true });
+  writeFileSync5(
     GLOBAL_CONFIG_PATH2,
     `${JSON.stringify(config, null, 2)}
 `,
@@ -2491,7 +2748,9 @@ function writeConfig(config) {
 }
 async function initCommand(options) {
   const { baseUrl, org, mcp, toolkit, userAccessKey, token } = options;
+  const existing = readExistingConfig();
   const config = {};
+  if (existing.settings) config.settings = existing.settings;
   if (org) {
     config.org = org;
   } else if (baseUrl) {
@@ -2601,10 +2860,10 @@ async function initInteractive() {
 }
 
 // src/commands/kill-daemon.ts
-import { existsSync as existsSync7, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync8, readdirSync as readdirSync2 } from "fs";
 function killDaemonCommand() {
   const socketDir = getSocketDir();
-  if (!existsSync7(socketDir)) {
+  if (!existsSync8(socketDir)) {
     console.log("No daemons running.");
     return;
   }
@@ -2654,14 +2913,14 @@ async function listCommand(options) {
     console.error(error.message);
     process.exit(1 /* CLIENT_ERROR */);
   }
-  const { serverConfig } = loaded;
+  const { serverConfig, settings } = loaded;
   const serverLabel = "server";
   let connection = null;
   let tools = [];
   let instructions;
   let errorMsg;
   try {
-    connection = await getConnection(serverLabel, serverConfig);
+    connection = await getConnection(serverLabel, serverConfig, settings);
     tools = await connection.listTools();
     instructions = await connection.getInstructions();
     debug(`${serverLabel}: loaded ${tools.length} tools`);
@@ -2703,18 +2962,18 @@ async function logoutCommand(options) {
 }
 
 // src/commands/whoami.ts
-import { existsSync as existsSync8, readFileSync as readFileSync4, statSync } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join6, resolve as resolve3 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync6, statSync } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join7, resolve as resolve4 } from "path";
 function getResolvedConfigPath(explicitPath) {
   if (explicitPath) {
-    return resolve3(explicitPath);
+    return resolve4(explicitPath);
   }
-  if (process.env.MCP_CONFIG_PATH) {
-    return resolve3(process.env.MCP_CONFIG_PATH);
+  if (process.env.MCP_S_CLI_CONFIG_PATH) {
+    return resolve4(process.env.MCP_S_CLI_CONFIG_PATH);
   }
-  const defaultPath = join6(homedir5(), ".config", "mcp-s-cli", "config.json");
-  if (existsSync8(defaultPath)) {
+  const defaultPath = join7(homedir6(), ".config", "mcp-s-cli", "config.json");
+  if (existsSync9(defaultPath)) {
     return defaultPath;
   }
   return null;
@@ -2742,15 +3001,15 @@ async function whoamiCommand(options) {
     console.log(`  Error loading config: ${err.message}`);
     return;
   }
-  const authFilePath = join6(homedir5(), ".config", "mcp-s-cli", "auth.json");
+  const authFilePath = join7(homedir6(), ".config", "mcp-s-cli", "auth.json");
   console.log("");
   console.log("OAuth Tokens");
   console.log(`  Path: ${authFilePath}`);
-  if (!existsSync8(authFilePath)) {
+  if (!existsSync9(authFilePath)) {
     console.log("  (no tokens stored)");
   } else {
     try {
-      const raw2 = readFileSync4(authFilePath, "utf-8");
+      const raw2 = readFileSync6(authFilePath, "utf-8");
       const data = JSON.parse(raw2);
       const tokenEntries = Object.entries(data.tokens ?? {});
       if (tokenEntries.length === 0) {
@@ -2760,9 +3019,9 @@ async function whoamiCommand(options) {
       console.log("  (could not read auth file)");
     }
   }
-  const historyPath = join6(homedir5(), ".config", "mcp-s-cli", "history.jsonl");
-  if (existsSync8(historyPath)) {
-    const lines = readFileSync4(historyPath, "utf-8").split("\n").filter(Boolean);
+  const historyPath = join7(homedir6(), ".config", "mcp-s-cli", "history.jsonl");
+  if (existsSync9(historyPath)) {
+    const lines = readFileSync6(historyPath, "utf-8").split("\n").filter(Boolean);
     const size = statSync(historyPath).size;
     const sizeStr = size >= 1024 * 1024 ? `${(size / (1024 * 1024)).toFixed(1)} MB` : size >= 1024 ? `${(size / 1024).toFixed(1)} KB` : `${size} B`;
     console.log("");
@@ -2824,6 +3083,10 @@ function parseArgs2(args) {
     switch (arg) {
       case "-h":
       case "--help":
+        if (positional[0] === "config") {
+          positional.push(arg);
+          break;
+        }
         result.command = "help";
         return result;
       case "-v":
@@ -2987,6 +3250,38 @@ function parseArgs2(args) {
     result.command = "kill-daemon";
     return result;
   }
+  if (firstArg === "enable") {
+    result.command = "enable";
+    return result;
+  }
+  if (firstArg === "disable") {
+    result.command = "disable";
+    return result;
+  }
+  if (firstArg === "config") {
+    result.command = "config";
+    const sub = positional[1];
+    if (!sub || sub === "--help" || sub === "-h" || sub === "help") {
+      printConfigHelp();
+      process.exit(0);
+    }
+    if (sub !== "set" && sub !== "get" && sub !== "show") {
+      console.error(
+        formatCliError({
+          code: 1 /* CLIENT_ERROR */,
+          type: "UNKNOWN_SUBCOMMAND",
+          message: `Unknown config subcommand: "${sub}"`,
+          details: "Valid subcommands: set, get, show",
+          suggestion: "Run mcp-s-cli config --help to see usage and valid keys"
+        })
+      );
+      process.exit(1 /* CLIENT_ERROR */);
+    }
+    result.configSubcommand = sub;
+    result.configKey = positional[2];
+    result.configValue = positional[3];
+    return result;
+  }
   if (firstArg === "init") {
     result.command = "init";
     if (result.baseUrl && result.org) {
@@ -3026,10 +3321,16 @@ Usage:
   mcp-s-cli whoami                           Show config location and auth state
   mcp-s-cli login                            Log in to the configured server via OAuth
   mcp-s-cli logout                           Log out (remove stored OAuth tokens)
+  mcp-s-cli config set <key> <value>         Set a value in config.json
+  mcp-s-cli config get <key>                 Get a value from config.json
+  mcp-s-cli config show                      Print full config.json
+  mcp-s-cli config --help                    List all config keys with types and defaults
   mcp-s-cli clear                            Clear server config (resets config.json to {})
   mcp-s-cli clear-auth                       Clear all stored auth data (sets auth.json to {})
   mcp-s-cli clear-history                    Delete the history file (~/.config/mcp-s-cli/history.jsonl)
   mcp-s-cli clear-skill                      Remove the mcp-s-cli skill from all agent skill directories
+  mcp-s-cli enable                           Enable mcp-s-cli
+  mcp-s-cli disable                          Disable mcp-s-cli
 
 Options:
   -h, --help               Show this help message
@@ -3061,30 +3362,33 @@ Examples:
   mcp-s-cli whoami                           # Show config and auth state
   mcp-s-cli login                            # Authenticate via OAuth
   mcp-s-cli logout                           # Remove stored OAuth tokens
+  mcp-s-cli config set settings.timeout 30   # Set request timeout to 30s
   mcp-s-cli clear                            # Reset server config
   mcp-s-cli clear-auth                       # Clear stored auth data
   mcp-s-cli clear-skill                      # Remove installed skill from all agents
   mcp-s-cli kill-daemon                      # Kill the running daemon process
+  mcp-s-cli enable                           # Enable mcp-s-cli
+  mcp-s-cli disable                          # Disable mcp-s-cli
 
 Environment Variables:
-  MCP_DAEMON=0           Disable connection caching (daemon mode, on by default)
-  MCP_DAEMON_TIMEOUT=N   Set daemon idle timeout in seconds (default: 300)
+  MCP_S_CLI_DEBUG=1          Enable debug output
+  MCP_S_CLI_STRICT_ENV=false Warn (instead of error) on missing \${VAR} in config
 
 Config File:
   The CLI looks for config.json in:
-    1. Path specified by MCP_CONFIG_PATH or -c/--config
+    1. Path specified by MCP_S_CLI_CONFIG_PATH or -c/--config
     2. ~/.config/mcp-s-cli/config.json
 
   'mcp-s-cli init' always writes to ~/.config/mcp-s-cli/config.json
 `);
 }
-function appendHistory(argv) {
-  if (process.env.MCP_CLI_HISTORY !== "1") return;
+function appendHistory(argv, history) {
+  if (!history) return;
   try {
-    const dir = join7(homedir6(), ".config", "mcp-s-cli");
-    mkdirSync5(dir, { recursive: true });
+    const dir = join8(homedir7(), ".config", "mcp-s-cli");
+    mkdirSync6(dir, { recursive: true });
     const entry = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), args: argv });
-    appendFileSync(join7(dir, "history.jsonl"), `${entry}
+    appendFileSync(join8(dir, "history.jsonl"), `${entry}
 `, "utf8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -3095,8 +3399,29 @@ function appendHistory(argv) {
   }
 }
 async function main() {
-  appendHistory(process.argv.slice(2));
-  const args = parseArgs2(process.argv.slice(2));
+  const argv = process.argv.slice(2);
+  const args = parseArgs2(argv);
+  let settings;
+  let enabled;
+  try {
+    const loaded = await loadConfig(args.configPath);
+    settings = loaded.settings;
+    enabled = loaded.raw.enabled;
+  } catch {
+  }
+  appendHistory(argv, settings?.history);
+  const META_COMMANDS = /* @__PURE__ */ new Set([
+    "enable",
+    "disable",
+    "config",
+    "help",
+    "version",
+    "init"
+  ]);
+  if (!(enabled ?? true) && !META_COMMANDS.has(args.command)) {
+    console.error("mcp-s-cli is disabled. To enable, run: mcp-s-cli enable");
+    process.exit(1);
+  }
   switch (args.command) {
     case "help":
       printHelp();
@@ -3131,6 +3456,14 @@ async function main() {
         configPath: args.configPath
       });
       break;
+    case "config":
+      configCommand({
+        subcommand: args.configSubcommand ?? "show",
+        key: args.configKey,
+        value: args.configValue,
+        configPath: args.configPath
+      });
+      break;
     case "init":
       if (args.baseUrl || args.org) {
         await initCommand({
@@ -3184,6 +3517,22 @@ async function main() {
       }
       break;
     }
+    case "enable":
+      configSetCommand({
+        key: "enabled",
+        value: "true",
+        configPath: args.configPath
+      });
+      console.log("mcp-s-cli is now enabled.");
+      break;
+    case "disable":
+      configSetCommand({
+        key: "enabled",
+        value: "false",
+        configPath: args.configPath
+      });
+      console.log("mcp-s-cli is now disabled.");
+      break;
   }
 }
 process.on("SIGINT", () => {