@mcp-s/cli 0.0.9

package/dist/daemon.js

@@ -0,0 +1,1023 @@
+// src/daemon.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { createServer } from "net";
+import { dirname } from "path";
+
+// src/client.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// src/auth.ts
+var tokenStorage = null;
+var clientStorage = null;
+async function getAuthFilePath() {
+  const os = await import("os");
+  const path = await import("path");
+  const fs = await import("fs");
+  const dir = path.join(os.homedir(), ".config", "mcp-s-cli");
+  fs.mkdirSync(dir, { recursive: true });
+  return path.join(dir, "auth.json");
+}
+async function loadAuthData() {
+  if (tokenStorage !== null && clientStorage !== null) {
+    return;
+  }
+  tokenStorage = /* @__PURE__ */ new Map();
+  clientStorage = /* @__PURE__ */ new Map();
+  try {
+    const fs = await import("fs/promises");
+    const authPath = await getAuthFilePath();
+    const data = await fs.readFile(authPath, "utf-8");
+    const parsed = JSON.parse(data);
+    if (parsed.tokens) {
+      for (const [key, value] of Object.entries(parsed.tokens)) {
+        tokenStorage.set(key, value);
+      }
+    }
+    if (parsed.clients) {
+      for (const [key, value] of Object.entries(parsed.clients)) {
+        clientStorage.set(key, value);
+      }
+    }
+  } catch {
+  }
+}
+async function saveAuthData() {
+  if (!tokenStorage || !clientStorage) {
+    return;
+  }
+  try {
+    const fs = await import("fs/promises");
+    const authPath = await getAuthFilePath();
+    const data = {
+      tokens: Object.fromEntries(tokenStorage),
+      clients: Object.fromEntries(clientStorage)
+    };
+    await fs.writeFile(authPath, JSON.stringify(data, null, 2), {
+      mode: 384
+    });
+  } catch (err) {
+    if (process.env.MCP_DEBUG) {
+      console.error(
+        `[mcp-s-cli] Failed to save auth data: ${err.message}`
+      );
+    }
+  }
+}
+async function getTokenStorage() {
+  await loadAuthData();
+  return tokenStorage ?? /* @__PURE__ */ new Map();
+}
+async function getClientStorage() {
+  await loadAuthData();
+  return clientStorage ?? /* @__PURE__ */ new Map();
+}
+function generateCodeVerifier() {
+  const array = new Uint8Array(32);
+  crypto.getRandomValues(array);
+  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+async function generateCodeChallenge(verifier) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(verifier);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = new Uint8Array(hashBuffer);
+  const base64 = btoa(String.fromCharCode(...hashArray)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return base64;
+}
+function parseWWWAuthenticateHeader(header) {
+  const challenge = {};
+  const bearerMatch = header.match(/Bearer\s+(.*)/i);
+  if (!bearerMatch) {
+    return challenge;
+  }
+  const params = bearerMatch[1] ?? "";
+  const paramRegex = /(\w+)="([^"]*)"/g;
+  for (const match of params.matchAll(paramRegex)) {
+    const [, key, value] = match;
+    if (key === "error") {
+      challenge.error = value;
+    } else if (key === "error_description") {
+      challenge.error_description = value;
+    } else if (key === "resource_metadata") {
+      challenge.resource_metadata = value;
+    }
+  }
+  return challenge;
+}
+async function fetchProtectedResourceMetadata(metadataUrl) {
+  try {
+    const response = await fetch(metadataUrl, {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function fetchAuthServerMetadata(authServerUrl) {
+  try {
+    const parsed = new URL(authServerUrl);
+    const metadataUrl = `${parsed.protocol}//${parsed.host}/.well-known/oauth-authorization-server`;
+    const response = await fetch(metadataUrl, {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function registerOAuthClient(registrationEndpoint, redirectUri) {
+  try {
+    const clientMetadata = {
+      client_name: "mcp-s-cli",
+      redirect_uris: [redirectUri],
+      grant_types: ["authorization_code"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none"
+    };
+    const response = await fetch(registrationEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(clientMetadata),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function exchangeAuthorizationCode(tokenEndpoint, clientId, code, codeVerifier, redirectUri) {
+  try {
+    const params = new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      client_id: clientId,
+      code_verifier: codeVerifier,
+      redirect_uri: redirectUri
+    });
+    const response = await fetch(tokenEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: params.toString(),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function startCallbackServer(port) {
+  const http = await import("http");
+  return new Promise((resolve2, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+      const code = url.searchParams.get("code");
+      const error = url.searchParams.get("error");
+      if (error) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body>
+              <h1>Authorization Failed</h1>
+              <p>Error: ${error}</p>
+              <p>You can close this window.</p>
+            </body>
+          </html>
+        `);
+        server.close();
+        reject(new Error(`OAuth error: ${error}`));
+        return;
+      }
+      if (code) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body>
+              <h1>Authorization Successful</h1>
+              <p>You can close this window and return to the CLI.</p>
+            </body>
+          </html>
+        `);
+        server.close();
+        resolve2(code);
+        return;
+      }
+      res.writeHead(400, { "Content-Type": "text/html" });
+      res.end("<html><body><h1>Invalid Request</h1></body></html>");
+    });
+    server.listen(port, "127.0.0.1", () => {
+    });
+    setTimeout(
+      () => {
+        server.close();
+        reject(new Error("OAuth callback timeout"));
+      },
+      5 * 60 * 1e3
+    );
+  });
+}
+async function getOpenCommand() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return "open";
+  }
+  if (platform === "win32") {
+    return "start";
+  }
+  if (platform === "linux") {
+    return "xdg-open";
+  }
+  return null;
+}
+async function performOAuthFlow(authServerUrl, resourceUrl) {
+  const authMetadata = await fetchAuthServerMetadata(authServerUrl);
+  if (!authMetadata) {
+    console.error("Failed to fetch authorization server metadata");
+    return null;
+  }
+  if (!authMetadata.registration_endpoint) {
+    console.error(
+      "Authorization server does not support dynamic client registration"
+    );
+    return null;
+  }
+  const callbackPort = 8085;
+  const redirectUri = `http://127.0.0.1:${callbackPort}/callback`;
+  const serverKey = new URL(authServerUrl).origin;
+  const clients = await getClientStorage();
+  let clientInfo = clients.get(serverKey);
+  if (!clientInfo) {
+    const newClientInfo = await registerOAuthClient(
+      authMetadata.registration_endpoint,
+      redirectUri
+    );
+    if (!newClientInfo) {
+      console.error("Failed to register OAuth client");
+      return null;
+    }
+    clientInfo = newClientInfo;
+    clients.set(serverKey, clientInfo);
+    await saveAuthData();
+  }
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = await generateCodeChallenge(codeVerifier);
+  const authUrl = new URL(authMetadata.authorization_endpoint);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("client_id", clientInfo.client_id);
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("code_challenge", codeChallenge);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+  authUrl.searchParams.set("resource", resourceUrl);
+  console.error(
+    "\nAuthentication required. Opening browser for authorization..."
+  );
+  console.error(`If the browser doesn't open, visit: ${authUrl.toString()}
+`);
+  const open = await getOpenCommand();
+  if (open) {
+    try {
+      const { spawn: spawn2 } = await import("child_process");
+      spawn2(open, [authUrl.toString()], {
+        detached: true,
+        stdio: "ignore"
+      }).unref();
+    } catch {
+      console.error("Could not open browser automatically.");
+    }
+  }
+  try {
+    const code = await startCallbackServer(callbackPort);
+    const tokens = await exchangeAuthorizationCode(
+      authMetadata.token_endpoint,
+      clientInfo.client_id,
+      code,
+      codeVerifier,
+      redirectUri
+    );
+    if (tokens) {
+      const resourceOrigin = new URL(resourceUrl).origin;
+      const tokenMap = await getTokenStorage();
+      tokenMap.set(resourceOrigin, tokens);
+      await saveAuthData();
+    }
+    return tokens;
+  } catch (error) {
+    console.error("OAuth flow failed:", error);
+    return null;
+  }
+}
+async function getStoredTokens(url) {
+  const origin = new URL(url).origin;
+  const tokens = await getTokenStorage();
+  return tokens.get(origin);
+}
+async function storeTokens(url, tokens) {
+  const origin = new URL(url).origin;
+  const tokenMap = await getTokenStorage();
+  tokenMap.set(origin, tokens);
+  await saveAuthData();
+}
+
+// src/config.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+function isHttpServer(config) {
+  return "url" in config;
+}
+var DEFAULT_TIMEOUT_SECONDS = 1800;
+var DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_SECONDS * 1e3;
+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) {
+    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;
+    }
+  }
+  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;
+    }
+  }
+  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;
+    }
+  }
+  return DEFAULT_RETRY_DELAY_MS;
+}
+var DAEMON_SERVER_NAME = "mcp-s-cli";
+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;
+    }
+  }
+  return DEFAULT_DAEMON_TIMEOUT_SECONDS * 1e3;
+}
+function getSocketDir() {
+  const uid = process.getuid?.() ?? "unknown";
+  const base = process.platform === "darwin" ? "/tmp" : "/tmp";
+  return join(base, `mcp-s-cli-${uid}`);
+}
+function getSocketPath() {
+  return join(getSocketDir(), `${DAEMON_SERVER_NAME}.sock`);
+}
+function getPidPath() {
+  return join(getSocketDir(), `${DAEMON_SERVER_NAME}.pid`);
+}
+function getReadyPath() {
+  return join(getSocketDir(), `${DAEMON_SERVER_NAME}.ready`);
+}
+function getConfigHash(config) {
+  const str = JSON.stringify(config, Object.keys(config).sort());
+  return createHash("sha256").update(str).digest("hex").slice(0, 16);
+}
+
+// src/daemon-client.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync2, readdirSync } from "fs";
+import { createConnection } from "net";
+import { join as join2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/version.ts
+var VERSION = "0.0.9";
+
+// src/client.ts
+function getRetryConfig() {
+  const totalBudgetMs = getTimeoutMs();
+  const maxRetries = getMaxRetries();
+  const baseDelayMs = getRetryDelayMs();
+  const retryBudgetMs = Math.max(0, totalBudgetMs - 5e3);
+  return {
+    maxRetries,
+    baseDelayMs,
+    maxDelayMs: Math.min(1e4, retryBudgetMs / 2),
+    totalBudgetMs
+  };
+}
+function isTransientError(error) {
+  const nodeError = error;
+  if (nodeError.code) {
+    const transientCodes = [
+      "ECONNREFUSED",
+      "ECONNRESET",
+      "ETIMEDOUT",
+      "ENOTFOUND",
+      "EPIPE",
+      "ENETUNREACH",
+      "EHOSTUNREACH",
+      "EAI_AGAIN"
+    ];
+    if (transientCodes.includes(nodeError.code)) {
+      return true;
+    }
+  }
+  const message = error.message;
+  if (/^(502|503|504|429)\b/.test(message)) return true;
+  if (/\b(http|status(\s+code)?)\s*(502|503|504|429)\b/i.test(message))
+    return true;
+  if (/\b(502|503|504|429)\s+(bad gateway|service unavailable|gateway timeout|too many requests)/i.test(
+    message
+  ))
+    return true;
+  if (/network\s*(error|fail|unavailable|timeout)/i.test(message)) return true;
+  if (/connection\s*(reset|refused|timeout)/i.test(message)) return true;
+  if (/\btimeout\b/i.test(message)) return true;
+  return false;
+}
+function calculateDelay(attempt, config) {
+  const exponentialDelay = config.baseDelayMs * 2 ** attempt;
+  const cappedDelay = Math.min(exponentialDelay, config.maxDelayMs);
+  const jitter = cappedDelay * 0.25 * (Math.random() * 2 - 1);
+  return Math.round(cappedDelay + jitter);
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function withRetry(fn, operationName, config = getRetryConfig()) {
+  let lastError;
+  const startTime = Date.now();
+  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+    const elapsed = Date.now() - startTime;
+    if (elapsed >= config.totalBudgetMs) {
+      debug(`${operationName}: timeout budget exhausted after ${elapsed}ms`);
+      break;
+    }
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      const remainingBudget = config.totalBudgetMs - (Date.now() - startTime);
+      const shouldRetry = attempt < config.maxRetries && isTransientError(lastError) && remainingBudget > 1e3;
+      if (shouldRetry) {
+        const delay = Math.min(
+          calculateDelay(attempt, config),
+          remainingBudget - 1e3
+        );
+        debug(
+          `${operationName} failed (attempt ${attempt + 1}/${config.maxRetries + 1}): ${lastError.message}. Retrying in ${delay}ms...`
+        );
+        await sleep(delay);
+      } else {
+        throw lastError;
+      }
+    }
+  }
+  throw lastError;
+}
+async function connectToServer(serverName, config) {
+  if (isHttpServer(config)) {
+    return connectToHttpServer(serverName, config);
+  }
+  const stderrChunks = [];
+  return withRetry(async () => {
+    const client = new Client(
+      {
+        name: "mcp-s-cli",
+        version: VERSION
+      },
+      {
+        capabilities: {}
+      }
+    );
+    const transport = createStdioTransport(config);
+    const stderrStream = transport.stderr;
+    if (stderrStream) {
+      stderrStream.on("data", (chunk) => {
+        const text = chunk.toString();
+        stderrChunks.push(text);
+        process.stderr.write(`[${serverName}] ${text}`);
+      });
+    }
+    try {
+      await client.connect(transport);
+    } catch (error) {
+      const stderrOutput = stderrChunks.join("").trim();
+      if (stderrOutput) {
+        const err = error;
+        err.message = `${err.message}
+
+Server stderr:
+${stderrOutput}`;
+      }
+      throw error;
+    }
+    const stderrStream2 = transport.stderr;
+    if (stderrStream2) {
+      stderrStream2.on("data", (chunk) => {
+        process.stderr.write(chunk);
+      });
+    }
+    return {
+      client,
+      close: async () => {
+        await client.close();
+      }
+    };
+  }, `connect to ${serverName}`);
+}
+async function connectToHttpServer(serverName, config) {
+  const oauthEnabled = process.env.MCP_NO_OAUTH !== "1";
+  return withRetry(async () => {
+    const configuredAuth = config.headers?.Authorization || config.headers?.authorization;
+    let headers = { ...config.headers };
+    if (!configuredAuth) {
+      const stored = await getStoredTokens(config.url);
+      if (stored) {
+        headers = {
+          ...headers,
+          Authorization: `Bearer ${stored.access_token}`
+        };
+      }
+    }
+    return attemptHttpConnect(serverName, config, headers, oauthEnabled);
+  }, `connect to ${serverName}`);
+}
+async function attemptHttpConnect(serverName, config, headers, oauthEnabled = true) {
+  const hasAuth = Boolean(headers.Authorization || headers.authorization);
+  let effectiveHeaders = headers;
+  let oauthAlreadyRan = false;
+  if (oauthEnabled && !hasAuth) {
+    const probeTokens = await probeAndOAuth(serverName, config, headers);
+    if (probeTokens) {
+      effectiveHeaders = {
+        ...headers,
+        Authorization: `Bearer ${probeTokens.access_token}`
+      };
+      oauthAlreadyRan = true;
+    }
+  }
+  const client = new Client(
+    { name: "mcp-s-cli", version: VERSION },
+    { capabilities: {} }
+  );
+  const transport = new StreamableHTTPClientTransport(new URL(config.url), {
+    requestInit: { headers: effectiveHeaders }
+  });
+  try {
+    await client.connect(transport);
+    return {
+      client,
+      close: async () => {
+        await client.close();
+      }
+    };
+  } catch (connectError) {
+    if (oauthAlreadyRan) {
+      throw connectError;
+    }
+    const errMsg = connectError.message ?? "";
+    const isAuthError = errMsg.includes("401") || errMsg.toLowerCase().includes("unauthorized") || errMsg.includes("invalid_token") || errMsg.toLowerCase().includes("missing authorization") || errMsg.toLowerCase().includes("authentication") || errMsg.toLowerCase().includes("access denied");
+    if (!isAuthError || !oauthEnabled) {
+      throw connectError;
+    }
+    debug(`Auth error from ${serverName}, probing for OAuth metadata`);
+    const retryTokens = await probeAndOAuth(
+      serverName,
+      config,
+      effectiveHeaders,
+      true
+    );
+    if (!retryTokens) {
+      throw connectError;
+    }
+    const newHeaders = {
+      ...effectiveHeaders,
+      Authorization: `Bearer ${retryTokens.access_token}`
+    };
+    const newClient = new Client(
+      { name: "mcp-s-cli", version: VERSION },
+      { capabilities: {} }
+    );
+    const newTransport = new StreamableHTTPClientTransport(
+      new URL(config.url),
+      { requestInit: { headers: newHeaders } }
+    );
+    await newClient.connect(newTransport);
+    return {
+      client: newClient,
+      close: async () => {
+        await newClient.close();
+      }
+    };
+  }
+}
+async function probeAndOAuth(serverName, config, _headers, force = false) {
+  debug(`Probing ${serverName} for OAuth metadata`);
+  let probeResponse;
+  try {
+    probeResponse = await fetch(config.url, {
+      signal: AbortSignal.timeout(1e4)
+    });
+  } catch {
+    return null;
+  }
+  if (!force && probeResponse.status !== 401) {
+    return null;
+  }
+  const wwwAuth = probeResponse.headers.get("WWW-Authenticate");
+  if (!wwwAuth) {
+    return null;
+  }
+  const challenge = parseWWWAuthenticateHeader(wwwAuth);
+  if (!challenge.resource_metadata) {
+    return null;
+  }
+  const resourceMetadata = await fetchProtectedResourceMetadata(
+    challenge.resource_metadata
+  );
+  if (!resourceMetadata?.authorization_servers?.[0]) {
+    return null;
+  }
+  const newTokens = await performOAuthFlow(
+    resourceMetadata.authorization_servers[0],
+    resourceMetadata.resource
+  );
+  if (newTokens) {
+    await storeTokens(config.url, newTokens);
+  }
+  return newTokens;
+}
+function createStdioTransport(config) {
+  const mergedEnv = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0) {
+      mergedEnv[key] = value;
+    }
+  }
+  if (config.env) {
+    Object.assign(mergedEnv, config.env);
+  }
+  return new StdioClientTransport({
+    command: config.command,
+    args: config.args,
+    env: mergedEnv,
+    cwd: config.cwd,
+    stderr: "pipe"
+    // Capture stderr for better error messages
+  });
+}
+async function listTools(client) {
+  return withRetry(async () => {
+    const result = await client.listTools();
+    return result.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema
+    }));
+  }, "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}`);
+}
+
+// src/daemon.ts
+function writePidFile(serverName, configHash) {
+  const pidPath = getPidPath();
+  const dir = dirname(pidPath);
+  if (!existsSync3(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  const content = {
+    pid: process.pid,
+    configHash,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync(pidPath, JSON.stringify(content), { mode: 384 });
+}
+function readPidFile(serverName) {
+  const pidPath = getPidPath();
+  if (!existsSync3(pidPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync2(pidPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function removePidFile(serverName) {
+  const pidPath = getPidPath();
+  try {
+    if (existsSync3(pidPath)) {
+      unlinkSync(pidPath);
+    }
+  } catch {
+  }
+}
+function removeSocketFile(serverName) {
+  const socketPath = getSocketPath();
+  try {
+    if (existsSync3(socketPath)) {
+      unlinkSync(socketPath);
+    }
+  } catch {
+  }
+}
+function removeReadyFile(serverName) {
+  const readyPath = getReadyPath();
+  try {
+    if (existsSync3(readyPath)) {
+      unlinkSync(readyPath);
+    }
+  } catch {
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function killProcess(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runDaemon(serverName, config) {
+  const socketPath = getSocketPath();
+  const configHash = getConfigHash(config);
+  const timeoutMs = getDaemonTimeoutMs();
+  let idleTimer = null;
+  let mcpClient = null;
+  let server = null;
+  const activeConnections = /* @__PURE__ */ new Set();
+  const cleanup = async () => {
+    debug(`[daemon:${serverName}] Shutting down...`);
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+    for (const conn of activeConnections) {
+      try {
+        conn.end();
+      } catch {
+      }
+    }
+    activeConnections.clear();
+    if (mcpClient) {
+      try {
+        await mcpClient.close();
+      } catch {
+      }
+      mcpClient = null;
+    }
+    if (server) {
+      try {
+        server.close();
+      } catch {
+      }
+      server = null;
+    }
+    removeSocketFile(serverName);
+    removePidFile(serverName);
+    removeReadyFile(serverName);
+    debug(`[daemon:${serverName}] Cleanup complete`);
+  };
+  const resetIdleTimer = () => {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+    }
+    idleTimer = setTimeout(async () => {
+      debug(`[daemon:${serverName}] Idle timeout reached, shutting down`);
+      await cleanup();
+      process.exit(0);
+    }, timeoutMs);
+  };
+  process.on("SIGTERM", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+  process.on("SIGINT", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+  const socketDir = getSocketDir();
+  if (!existsSync3(socketDir)) {
+    mkdirSync(socketDir, { recursive: true, mode: 448 });
+  }
+  removeSocketFile(serverName);
+  removeReadyFile(serverName);
+  writePidFile(serverName, configHash);
+  try {
+    debug(`[daemon:${serverName}] Connecting to MCP server...`);
+    mcpClient = await connectToServer(serverName, config);
+    debug(`[daemon:${serverName}] Connected to MCP server`);
+  } catch (error) {
+    console.error(
+      `[daemon:${serverName}] Failed to connect:`,
+      error.message
+    );
+    await cleanup();
+    process.exit(1);
+  }
+  const handleRequest = async (data) => {
+    resetIdleTimer();
+    let request;
+    try {
+      request = JSON.parse(data.toString());
+    } catch {
+      return {
+        id: "unknown",
+        success: false,
+        error: { code: "INVALID_REQUEST", message: "Invalid JSON" }
+      };
+    }
+    debug(`[daemon:${serverName}] Request: ${request.type} (${request.id})`);
+    if (!mcpClient) {
+      return {
+        id: request.id,
+        success: false,
+        error: { code: "NOT_CONNECTED", message: "MCP client not connected" }
+      };
+    }
+    try {
+      switch (request.type) {
+        case "ping":
+          return { id: request.id, success: true, data: "pong" };
+        case "listTools": {
+          const tools = await listTools(mcpClient.client);
+          return { id: request.id, success: true, data: tools };
+        }
+        case "callTool": {
+          if (!request.toolName) {
+            return {
+              id: request.id,
+              success: false,
+              error: { code: "MISSING_TOOL", message: "toolName required" }
+            };
+          }
+          const result = await callTool(
+            mcpClient.client,
+            request.toolName,
+            request.args ?? {}
+          );
+          return { id: request.id, success: true, data: result };
+        }
+        case "getInstructions": {
+          const instructions = mcpClient.client.getInstructions();
+          return { id: request.id, success: true, data: instructions };
+        }
+        case "close":
+          setTimeout(async () => {
+            await cleanup();
+            process.exit(0);
+          }, 100);
+          return { id: request.id, success: true, data: "closing" };
+        default:
+          return {
+            id: request.id,
+            success: false,
+            error: {
+              code: "UNKNOWN_TYPE",
+              message: `Unknown request type: ${request.type}`
+            }
+          };
+      }
+    } catch (error) {
+      const err = error;
+      return {
+        id: request.id,
+        success: false,
+        error: { code: "EXECUTION_ERROR", message: err.message }
+      };
+    }
+  };
+  await new Promise((resolve2, reject) => {
+    server = createServer((socket) => {
+      activeConnections.add(socket);
+      debug(`[daemon:${serverName}] Client connected`);
+      let buffer = "";
+      socket.on("data", async (data) => {
+        buffer += data.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          const response = await handleRequest(Buffer.from(line));
+          socket.write(`${JSON.stringify(response)}
+`);
+        }
+      });
+      socket.on("close", () => {
+        activeConnections.delete(socket);
+        debug(`[daemon:${serverName}] Client disconnected`);
+      });
+      socket.on("error", (error) => {
+        debug(`[daemon:${serverName}] Socket error: ${error.message}`);
+        activeConnections.delete(socket);
+      });
+    });
+    server.on("error", reject);
+    server.listen(socketPath, () => {
+      debug(`[daemon:${serverName}] Listening on ${socketPath}`);
+      resetIdleTimer();
+      writeFileSync(getReadyPath(), String(process.pid), {
+        mode: 384
+      });
+      resolve2();
+    });
+  }).catch(async (error) => {
+    console.error(
+      `[daemon:${serverName}] Failed to start socket server:`,
+      error.message
+    );
+    await cleanup();
+    process.exit(1);
+  });
+}
+if (process.argv[2] === "--daemon") {
+  const serverName = process.argv[3];
+  const configJson = process.argv[4];
+  if (!serverName || !configJson) {
+    console.error("Usage: daemon.ts --daemon <serverName> <configJson>");
+    process.exit(1);
+  }
+  let config;
+  try {
+    config = JSON.parse(configJson);
+  } catch {
+    console.error("Invalid config JSON");
+    process.exit(1);
+  }
+  runDaemon(serverName, config).catch((error) => {
+    console.error("Daemon failed:", error);
+    process.exit(1);
+  });
+}
+export {
+  isProcessRunning,
+  killProcess,
+  readPidFile,
+  removePidFile,
+  removeReadyFile,
+  removeSocketFile,
+  runDaemon,
+  writePidFile
+};