@mcp-s/cli 0.0.10 → 0.0.11

package/dist/daemon.js

@@ -414,7 +414,7 @@ import { join as join2 } from "path";
 import { fileURLToPath } from "url";
 
 // src/version.ts
-var VERSION = "0.0.10";
+var VERSION = "0.0.11";
 
 // src/client.ts
 function getRetryConfig(settings) {

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";
@@ -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" });
@@ -764,6 +764,7 @@ async function loadConfig(explicitPath) {
     throw new Error(formatCliError(configMissingFieldError(configPath)));
   }
   const knownFields = [
+    "enabled",
     "org",
     "baseUrl",
     "mcp",
@@ -1017,7 +1018,7 @@ async function runDaemon(serverName, config, settings) {
       };
     }
   };
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     server = createServer((socket) => {
       activeConnections.add(socket);
       debug(`[daemon:${serverName}] Client connected`);
@@ -1049,7 +1050,7 @@ async function runDaemon(serverName, config, settings) {
       writeFileSync(getReadyPath(), String(process.pid), {
         mode: 384
       });
-      resolve4();
+      resolve5();
     });
   }).catch(async (error) => {
     console.error(
@@ -1097,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) => {
@@ -1125,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();
@@ -1297,7 +1298,7 @@ async function cleanupOrphanedDaemons() {
 }
 
 // src/version.ts
-var VERSION = "0.0.10";
+var VERSION = "0.0.11";
 
 // src/client.ts
 function getRetryConfig(settings) {
@@ -1349,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;
@@ -1940,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 = "";
@@ -2068,97 +2310,97 @@ async function infoCommand(options) {
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, 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 {
@@ -2172,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,
@@ -2188,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(
@@ -2206,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: [],
@@ -2223,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,
@@ -2235,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) {
@@ -2256,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;
     }
@@ -2272,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;
@@ -2283,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"))
     };
   });
 }
@@ -2358,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,
@@ -2367,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);
     });
   });
 }
@@ -2409,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") {
@@ -2429,7 +2671,7 @@ async function select(opts) {
         }
         if (key.name === "return") {
           cleanup();
-          resolve4(options[idx].value);
+          resolve5(options[idx].value);
         }
       };
       const cleanup = () => {
@@ -2480,24 +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 (existsSync6(GLOBAL_CONFIG_PATH2)) {
-      return JSON.parse(readFileSync4(GLOBAL_CONFIG_PATH2, "utf-8"));
+    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)}
 `,
@@ -2618,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;
   }
@@ -2720,18 +2962,18 @@ async function logoutCommand(options) {
 }
 
 // src/commands/whoami.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5, 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_S_CLI_CONFIG_PATH) {
-    return resolve3(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;
@@ -2759,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 = readFileSync5(authFilePath, "utf-8");
+      const raw2 = readFileSync6(authFilePath, "utf-8");
       const data = JSON.parse(raw2);
       const tokenEntries = Object.entries(data.tokens ?? {});
       if (tokenEntries.length === 0) {
@@ -2777,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 = readFileSync5(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("");
@@ -2841,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":
@@ -3004,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) {
@@ -3043,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
@@ -3078,10 +3362,13 @@ 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_S_CLI_DEBUG=1          Enable debug output
@@ -3098,10 +3385,10 @@ Config File:
 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);
@@ -3115,12 +3402,26 @@ async function main() {
   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();
@@ -3155,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({
@@ -3208,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", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-s/cli",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "A lightweight CLI for connecting AI agents to the Webrix MCP Gateway",
   "type": "module",
   "main": "dist/index.js",