@mhingston5/conduit 1.1.3 → 1.1.5

package/README.md

@@ -97,6 +97,17 @@ npx conduit auth \
 
 This will start a temporary local server, open your browser for authorization, and print the generated `credentials` block for your `conduit.yaml`.
 
+For GitHub MCP (remote server OAuth), you can auto-discover endpoints and use PKCE:
+
+```bash
+npx conduit auth \
+  --client-id <id> \
+  --client-secret <secret> \
+  --mcp-url https://api.githubcopilot.com/mcp/ \
+  --scopes repo,read:org \
+  --pkce
+```
+
 ### 4. Execute TypeScript
 
 Using any [MCP Client](https://modelcontextprotocol.io/clients) (Claude Desktop, etc.), call `mcp_execute_typescript`:
@@ -104,7 +115,7 @@ Using any [MCP Client](https://modelcontextprotocol.io/clients) (Claude Desktop,
 ```ts
 // The agent writes this code:
 const result = await tools.filesystem.list_allowed_directories();
-console.log("Files:", result);
+console.log("Directories:", JSON.stringify(result.content));
 ```
 
 ### 5. Result
@@ -113,7 +124,7 @@ Conduit runs the code, handles the tool call securely, and returns:
 
 ```json
 {
-  "stdout": "Files: ['/tmp']\n",
+  "stdout": "Directories: [{\"type\":\"text\",\"text\":\"/tmp\"}]\n",
   "stderr": "",
   "exitCode": 0
 }

package/dist/index.d.ts

@@ -1,2 +1 @@
-
-export {  }
+#!/usr/bin/env node

package/dist/index.js

@@ -1,3 +1,5 @@
+#!/usr/bin/env node
+
 // src/index.ts
 import { Command } from "commander";
 
@@ -6,6 +8,7 @@ import { z } from "zod";
 import dotenv from "dotenv";
 import fs from "fs";
 import path from "path";
+import crypto from "crypto";
 import yaml from "js-yaml";
 var originalWrite = process.stdout.write;
 process.stdout.write = () => true;
@@ -58,7 +61,7 @@ var ConfigSchema = z.object({
     "[A-Za-z0-9-_]{20,}"
     // Default pattern from spec
   ]),
-  ipcBearerToken: z.string().optional().default(() => Math.random().toString(36).substring(7)),
+  ipcBearerToken: z.string().optional().default(() => crypto.randomUUID()),
   maxConcurrent: z.number().default(10),
   denoMaxPoolSize: z.number().default(10),
   pyodideMaxPoolSize: z.number().default(3),
@@ -192,6 +195,7 @@ function createLogger(configService) {
 
 // src/transport/socket.transport.ts
 import net from "net";
+import fs2 from "fs";
 import os from "os";
 import path2 from "path";
 
@@ -245,6 +249,13 @@ var SocketTransport = class {
         const socketPath = this.formatSocketPath(options.path);
         this.logger.info({ socketPath }, "Binding to IPC socket");
         if (os.platform() !== "win32" && path2.isAbsolute(socketPath)) {
+          try {
+            fs2.unlinkSync(socketPath);
+          } catch (error) {
+            if (error.code !== "ENOENT") {
+              this.logger.warn({ err: error, socketPath }, "Failed to unlink socket before binding");
+            }
+          }
         }
         this.server.listen(socketPath, () => {
           this.resolveAddress(resolve);
@@ -739,6 +750,9 @@ var RequestController = class {
       // Standard MCP method name
       case "mcp_discover_tools":
         return this.handleDiscoverTools(params, context, id);
+      case "resources/list":
+      case "prompts/list":
+        return { jsonrpc: "2.0", id, result: { items: [] } };
       case "mcp_list_tool_packages":
         return this.handleListToolPackages(params, context, id);
       case "mcp_list_tool_stubs":
@@ -832,19 +846,51 @@ var RequestController = class {
     }
   }
   async handleCallTool(params, context, id) {
+    if (!params) return this.errorResponse(id, -32602, "Missing parameters");
     const { name, arguments: toolArgs } = params;
     switch (name) {
       case "mcp_execute_typescript":
-        return this.handleExecuteTypeScript(toolArgs, context, id);
+        return this.handleExecuteToolCall("typescript", toolArgs, context, id);
       case "mcp_execute_python":
-        return this.handleExecutePython(toolArgs, context, id);
+        return this.handleExecuteToolCall("python", toolArgs, context, id);
       case "mcp_execute_isolate":
-        return this.handleExecuteIsolate(toolArgs, context, id);
+        return this.handleExecuteToolCall("isolate", toolArgs, context, id);
     }
     const response = await this.gatewayService.callTool(name, toolArgs, context);
     return { ...response, id };
   }
+  formatExecutionResult(result) {
+    const structured = {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode
+    };
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(structured)
+      }],
+      structuredContent: structured
+    };
+  }
+  async handleExecuteToolCall(mode, params, context, id) {
+    if (!params) return this.errorResponse(id, -32602, "Missing parameters");
+    const { code, limits, allowedTools } = params;
+    if (Array.isArray(allowedTools)) {
+      context.allowedTools = allowedTools;
+    }
+    const result = mode === "typescript" ? await this.executionService.executeTypeScript(code, limits, context, allowedTools) : mode === "python" ? await this.executionService.executePython(code, limits, context, allowedTools) : await this.executionService.executeIsolate(code, limits, context, allowedTools);
+    if (result.error) {
+      return this.errorResponse(id, result.error.code, result.error.message);
+    }
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: this.formatExecutionResult(result)
+    };
+  }
   async handleExecuteTypeScript(params, context, id) {
+    if (!params) return this.errorResponse(id, -32602, "Missing parameters");
     const { code, limits, allowedTools } = params;
     if (Array.isArray(allowedTools)) {
       context.allowedTools = allowedTools;
@@ -864,6 +910,7 @@ var RequestController = class {
     };
   }
   async handleExecutePython(params, context, id) {
+    if (!params) return this.errorResponse(id, -32602, "Missing parameters");
     const { code, limits, allowedTools } = params;
     if (Array.isArray(allowedTools)) {
       context.allowedTools = allowedTools;
@@ -906,6 +953,7 @@ var RequestController = class {
     };
   }
   async handleExecuteIsolate(params, context, id) {
+    if (!params) return this.errorResponse(id, -32602, "Missing parameters");
     const { code, limits, allowedTools } = params;
     if (Array.isArray(allowedTools)) {
       context.allowedTools = allowedTools;
@@ -1008,23 +1056,29 @@ var UpstreamClient = class {
     }
     try {
       await this.ensureConnected();
-      if (request.method === "list_tools") {
+      if (request.method === "list_tools" || request.method === "tools/list") {
         const result = await this.mcpClient.listTools();
         return {
           jsonrpc: "2.0",
           id: request.id,
           result
         };
-      } else if (request.method === "call_tool") {
+      } else if (request.method === "call_tool" || request.method === "tools/call") {
         const params = request.params;
         const result = await this.mcpClient.callTool({
           name: params.name,
           arguments: params.arguments
         });
+        const normalizedResult = result && Array.isArray(result.content) ? result : {
+          content: [{
+            type: "text",
+            text: typeof result === "string" ? result : JSON.stringify(result ?? null)
+          }]
+        };
         return {
           jsonrpc: "2.0",
           id: request.id,
-          result
+          result: normalizedResult
         };
       } else {
         const result = await this.mcpClient.request(
@@ -1178,21 +1232,29 @@ var AuthService = class {
     }
   }
   async doRefresh(creds, cacheKey) {
-    if (!creds.tokenUrl || !creds.refreshToken || !creds.clientId || !creds.clientSecret) {
+    if (!creds.tokenUrl || !creds.refreshToken || !creds.clientId) {
       throw new Error("OAuth2 credentials missing required fields for refresh");
     }
     this.logger.info({ tokenUrl: creds.tokenUrl, clientId: creds.clientId }, "Refreshing OAuth2 token");
     try {
-      const response = await axios3.post(creds.tokenUrl, {
-        grant_type: "refresh_token",
-        refresh_token: creds.refreshToken,
-        client_id: creds.clientId,
-        client_secret: creds.clientSecret
+      const body = new URLSearchParams();
+      body.set("grant_type", "refresh_token");
+      body.set("refresh_token", creds.refreshToken);
+      body.set("client_id", creds.clientId);
+      if (creds.clientSecret) {
+        body.set("client_secret", creds.clientSecret);
+      }
+      const response = await axios3.post(creds.tokenUrl, body, {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "Accept": "application/json"
+        }
       });
       const { access_token, expires_in } = response.data;
+      const expiresInSeconds = Number(expires_in) || 3600;
       this.tokenCache.set(cacheKey, {
         accessToken: access_token,
-        expiresAt: Date.now() + expires_in * 1e3
+        expiresAt: Date.now() + expiresInSeconds * 1e3
       });
       return `Bearer ${access_token}`;
     } catch (err) {
@@ -1299,7 +1361,7 @@ import addFormats from "ajv-formats";
 var BUILT_IN_TOOLS = [
   {
     name: "mcp_execute_typescript",
-    description: "Executes TypeScript code in a secure sandbox with access to `tools.*` SDK.",
+    description: "Executes TypeScript code in a secure sandbox. Access MCP tools via the global `tools` object (e.g. `filesystem__list_directory` -> `await tools.filesystem.list_directory(...)`).",
     inputSchema: {
       type: "object",
       properties: {
@@ -1310,7 +1372,7 @@ var BUILT_IN_TOOLS = [
         allowedTools: {
           type: "array",
           items: { type: "string" },
-          description: 'Optional list of tools the script is allowed to call (e.g. ["github.*"]).'
+          description: 'List of tool names (e.g. "filesystem.list_directory" or "filesystem.*") that the script is allowed to call.'
         }
       },
       required: ["code"]
@@ -1318,7 +1380,7 @@ var BUILT_IN_TOOLS = [
   },
   {
     name: "mcp_execute_python",
-    description: "Executes Python code in a secure sandbox with access to `tools.*` SDK.",
+    description: "Executes Python code in a secure sandbox. Access MCP tools via the global `tools` object (e.g. `filesystem__list_directory` -> `await tools.filesystem.list_directory(...)`).",
     inputSchema: {
       type: "object",
       properties: {
@@ -1329,7 +1391,7 @@ var BUILT_IN_TOOLS = [
         allowedTools: {
           type: "array",
           items: { type: "string" },
-          description: 'Optional list of tools the script is allowed to call (e.g. ["github.*"]).'
+          description: 'List of tool names (e.g. "filesystem.list_directory" or "filesystem.*") that the script is allowed to call.'
         }
       },
       required: ["code"]
@@ -1337,7 +1399,7 @@ var BUILT_IN_TOOLS = [
   },
   {
     name: "mcp_execute_isolate",
-    description: "Executes JavaScript code in a high-speed V8 isolate (no Deno/Node APIs).",
+    description: "Executes JavaScript code in a high-speed V8 isolate. Access MCP tools via the global `tools` object (e.g. `await tools.filesystem.list_directory(...)`). No Deno/Node APIs. Use `console.log` for output.",
     inputSchema: {
       type: "object",
       properties: {
@@ -1348,7 +1410,7 @@ var BUILT_IN_TOOLS = [
         allowedTools: {
           type: "array",
           items: { type: "string" },
-          description: "Optional list of tools the script is allowed to call."
+          description: 'List of tool names (e.g. "filesystem.list_directory" or "filesystem.*") that the script is allowed to call.'
         }
       },
       required: ["code"]
@@ -1413,7 +1475,7 @@ var GatewayService = class {
       const response = await client.call({
         jsonrpc: "2.0",
         id: "discovery",
-        method: "list_tools"
+        method: "tools/list"
       }, context);
       if (response.result?.tools) {
         tools = response.result.tools;
@@ -1461,7 +1523,7 @@ var GatewayService = class {
         const response = await client.call({
           jsonrpc: "2.0",
           id: "discovery",
-          method: "list_tools"
+          method: "tools/list"
           // Standard MCP method
         }, context);
         if (response.result?.tools) {
@@ -1563,7 +1625,7 @@ var GatewayService = class {
       response = await client.call({
         jsonrpc: "2.0",
         id: context.correlationId,
-        method: "call_tool",
+        method: "tools/call",
         params: {
           name: toolName,
           arguments: params
@@ -1591,7 +1653,7 @@ var GatewayService = class {
           const response = await client.call({
             jsonrpc: "2.0",
             id: "health",
-            method: "list_tools"
+            method: "tools/list"
           }, context);
           upstreamStatus[id] = response.error ? "degraded" : "active";
         } catch (err) {
@@ -1759,7 +1821,7 @@ var SessionManager = class {
 };
 
 // src/core/security.service.ts
-import crypto from "crypto";
+import crypto2 from "crypto";
 var SecurityService = class {
   logger;
   ipcToken;
@@ -1789,7 +1851,7 @@ var SecurityService = class {
     }
     const expected = Buffer.from(this.ipcToken);
     const actual = Buffer.from(token);
-    if (expected.length === actual.length && crypto.timingSafeEqual(expected, actual)) {
+    if (expected.length === actual.length && crypto2.timingSafeEqual(expected, actual)) {
       return true;
     }
     return !!this.sessionManager.getSession(token);
@@ -1852,14 +1914,14 @@ var OtelService = class {
 // src/executors/deno.executor.ts
 import { spawn, exec } from "child_process";
 import { promisify } from "util";
-import fs3 from "fs";
+import fs4 from "fs";
 import path4 from "path";
 import { platform } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/core/asset.utils.ts
 import path3 from "path";
-import fs2 from "fs";
+import fs3 from "fs";
 import { fileURLToPath } from "url";
 var __dirname = path3.dirname(fileURLToPath(import.meta.url));
 function resolveAssetPath(filename) {
@@ -1876,7 +1938,7 @@ function resolveAssetPath(filename) {
     path3.resolve(process.cwd(), "dist/assets", filename)
   ];
   for (const candidate of candidates) {
-    if (fs2.existsSync(candidate)) {
+    if (fs3.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -1900,7 +1962,7 @@ var DenoExecutor = class {
     if (this.shimContent) return this.shimContent;
     try {
       const assetPath = resolveAssetPath("deno-shim.ts");
-      this.shimContent = fs3.readFileSync(assetPath, "utf-8");
+      this.shimContent = fs4.readFileSync(assetPath, "utf-8");
       return this.shimContent;
     } catch (err) {
       throw new Error(`Failed to load Deno shim: ${err.message}`);
@@ -2142,7 +2204,7 @@ var DenoExecutor = class {
 
 // src/executors/pyodide.executor.ts
 import { Worker } from "worker_threads";
-import fs4 from "fs";
+import fs5 from "fs";
 import path5 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __dirname3 = path5.dirname(fileURLToPath3(import.meta.url));
@@ -2158,7 +2220,7 @@ var PyodideExecutor = class {
     if (this.shimContent) return this.shimContent;
     try {
       const assetPath = resolveAssetPath("python-shim.py");
-      this.shimContent = fs4.readFileSync(assetPath, "utf-8");
+      this.shimContent = fs5.readFileSync(assetPath, "utf-8");
       return this.shimContent;
     } catch (err) {
       throw new Error(`Failed to load Python shim: ${err.message}`);
@@ -2198,9 +2260,15 @@ var PyodideExecutor = class {
     });
   }
   createWorker(limits) {
-    let workerPath = path5.resolve(__dirname3, "./pyodide.worker.js");
-    if (!fs4.existsSync(workerPath)) {
-      workerPath = path5.resolve(__dirname3, "./pyodide.worker.ts");
+    const candidates = [
+      path5.resolve(__dirname3, "./pyodide.worker.js"),
+      path5.resolve(__dirname3, "./pyodide.worker.ts"),
+      path5.resolve(__dirname3, "./executors/pyodide.worker.js"),
+      path5.resolve(__dirname3, "./executors/pyodide.worker.ts")
+    ];
+    const workerPath = candidates.find((p) => fs5.existsSync(p));
+    if (!workerPath) {
+      throw new Error(`Pyodide worker not found. Tried: ${candidates.join(", ")}`);
     }
     return new Worker(workerPath, {
       execArgv: process.execArgv.includes("--loader") ? process.execArgv : [],
@@ -2676,7 +2744,7 @@ var SDKGenerator = class {
     } else {
       lines.push("const __allowedTools = null;");
     }
-    lines.push("const tools = {");
+    lines.push("const _tools = {");
     for (const [namespace, tools] of grouped.entries()) {
       const safeNamespace = this.isValidIdentifier(namespace) ? namespace : `["${this.escapeString(namespace)}"]`;
       if (this.isValidIdentifier(namespace)) {
@@ -2714,6 +2782,18 @@ var SDKGenerator = class {
       lines.push(`  },`);
     }
     lines.push("};");
+    lines.push(`
+const tools = new Proxy(_tools, {
+    get: (target, prop) => {
+        if (prop in target) return target[prop];
+        if (prop === 'then') return undefined;
+        if (typeof prop === 'string') {
+            throw new Error(\`Namespace '\${prop}' not found. It might be invalid, or all tools in it were disallowed.\`);
+        }
+        return undefined;
+    }
+});
+`);
     lines.push("(globalThis as any).tools = tools;");
     return lines.join("\n");
   }
@@ -2789,7 +2869,7 @@ var SDKGenerator = class {
     } else {
       lines.push("const __allowedTools = null;");
     }
-    lines.push("const tools = {");
+    lines.push("const _tools = {");
     for (const [namespace, tools] of grouped.entries()) {
       const safeNamespace = this.isValidIdentifier(namespace) ? namespace : `["${this.escapeString(namespace)}"]`;
       if (this.isValidIdentifier(namespace)) {
@@ -2825,6 +2905,18 @@ var SDKGenerator = class {
       lines.push(`  },`);
     }
     lines.push("};");
+    lines.push(`
+const tools = new Proxy(_tools, {
+    get: (target, prop) => {
+        if (prop in target) return target[prop];
+        if (prop === 'then') return undefined;
+        if (typeof prop === 'string') {
+            throw new Error(\`Namespace '\${prop}' not found. It might be invalid, or all tools in it were disallowed.\`);
+        }
+        return undefined;
+    }
+});
+`);
     return lines.join("\n");
   }
   /**
@@ -3085,11 +3177,97 @@ import Fastify2 from "fastify";
 import axios4 from "axios";
 import open from "open";
 import { v4 as uuidv43 } from "uuid";
+import crypto3 from "crypto";
+var AUTH_REQUEST_PAYLOAD = {
+  jsonrpc: "2.0",
+  id: "conduit-auth",
+  method: "initialize",
+  params: {
+    clientInfo: {
+      name: "conduit-auth",
+      version: "1.0.0"
+    }
+  }
+};
+function base64UrlEncode(buffer) {
+  return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function createCodeVerifier() {
+  return base64UrlEncode(crypto3.randomBytes(32));
+}
+function createCodeChallenge(verifier) {
+  return base64UrlEncode(crypto3.createHash("sha256").update(verifier).digest());
+}
+function parseResourceMetadataHeader(headerValue) {
+  if (!headerValue) return null;
+  const header = Array.isArray(headerValue) ? headerValue.join(",") : headerValue;
+  const match = header.match(/resource_metadata="([^"]+)"/i) || header.match(/resource_metadata=([^, ]+)/i);
+  return match ? match[1] : null;
+}
+async function discoverOAuthFromMcp(mcpUrl) {
+  const attempts = [
+    () => axios4.get(mcpUrl, { validateStatus: () => true }),
+    () => axios4.post(mcpUrl, AUTH_REQUEST_PAYLOAD, { validateStatus: () => true })
+  ];
+  let resourceMetadataUrl = null;
+  for (const attempt of attempts) {
+    const response = await attempt();
+    resourceMetadataUrl = parseResourceMetadataHeader(response.headers["www-authenticate"]);
+    if (resourceMetadataUrl) break;
+  }
+  if (!resourceMetadataUrl) {
+    throw new Error("Unable to discover OAuth metadata (missing WWW-Authenticate resource_metadata)");
+  }
+  const metadataResponse = await axios4.get(resourceMetadataUrl);
+  const metadata = metadataResponse.data;
+  let authUrl = metadata.authorization_endpoint;
+  let tokenUrl = metadata.token_endpoint;
+  let scopes = Array.isArray(metadata.scopes_supported) ? metadata.scopes_supported : void 0;
+  const resource = typeof metadata.resource === "string" ? metadata.resource : void 0;
+  if (!authUrl || !tokenUrl) {
+    const authServer = Array.isArray(metadata.authorization_servers) && metadata.authorization_servers[0] || metadata.issuer;
+    if (!authServer) {
+      throw new Error("OAuth metadata did not include authorization server info");
+    }
+    const asMetadataUrl = new URL("/.well-known/oauth-authorization-server", authServer).toString();
+    const asMetadataResponse = await axios4.get(asMetadataUrl);
+    const asMetadata = asMetadataResponse.data;
+    authUrl = authUrl || asMetadata.authorization_endpoint;
+    tokenUrl = tokenUrl || asMetadata.token_endpoint;
+    scopes = scopes || (Array.isArray(asMetadata.scopes_supported) ? asMetadata.scopes_supported : void 0);
+  }
+  if (!authUrl || !tokenUrl) {
+    throw new Error("OAuth discovery failed: missing authorization or token endpoint");
+  }
+  return { authUrl, tokenUrl, scopes, resource };
+}
+function normalizeScopes(rawScopes) {
+  if (!rawScopes) return void 0;
+  return rawScopes.split(",").map((scope) => scope.trim()).filter(Boolean).join(" ");
+}
 async function handleAuth(options) {
   const port = options.port || 3333;
   const redirectUri = `http://localhost:${port}/callback`;
   const state = uuidv43();
+  const codeVerifier = options.usePkce ? createCodeVerifier() : void 0;
+  const codeChallenge = codeVerifier ? createCodeChallenge(codeVerifier) : void 0;
   const fastify = Fastify2();
+  let resolvedScopes = normalizeScopes(options.scopes);
+  let resolvedAuthUrl = options.authUrl;
+  let resolvedTokenUrl = options.tokenUrl;
+  let resolvedResource;
+  if (options.mcpUrl) {
+    const discovered = await discoverOAuthFromMcp(options.mcpUrl);
+    resolvedAuthUrl = discovered.authUrl;
+    resolvedTokenUrl = discovered.tokenUrl;
+    resolvedResource = discovered.resource;
+    if (!resolvedScopes && discovered.scopes && discovered.scopes.length > 0) {
+      resolvedScopes = discovered.scopes.join(" ");
+    }
+  }
+  if (!resolvedAuthUrl || !resolvedTokenUrl) {
+    throw new Error("OAuth configuration missing authUrl or tokenUrl (set --mcp-url or provide both)");
+  }
   return new Promise((resolve, reject) => {
     fastify.get("/callback", async (request, reply) => {
       const { code, state: returnedState, error, error_description } = request.query;
@@ -3104,12 +3282,25 @@ async function handleAuth(options) {
         return;
       }
       try {
-        const response = await axios4.post(options.tokenUrl, {
-          grant_type: "authorization_code",
-          code,
-          redirect_uri: redirectUri,
-          client_id: options.clientId,
-          client_secret: options.clientSecret
+        const body = new URLSearchParams();
+        body.set("grant_type", "authorization_code");
+        body.set("code", code);
+        body.set("redirect_uri", redirectUri);
+        body.set("client_id", options.clientId);
+        if (options.clientSecret) {
+          body.set("client_secret", options.clientSecret);
+        }
+        if (codeVerifier) {
+          body.set("code_verifier", codeVerifier);
+        }
+        if (resolvedResource) {
+          body.set("resource", resolvedResource);
+        }
+        const response = await axios4.post(resolvedTokenUrl, body, {
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Accept": "application/json"
+          }
         });
         const { refresh_token, access_token } = response.data;
         console.log("\n--- Authentication Successful ---\n");
@@ -3117,9 +3308,14 @@ async function handleAuth(options) {
         console.log("credentials:");
         console.log("  type: oauth2");
         console.log(`  clientId: ${options.clientId}`);
-        console.log(`  clientSecret: ${options.clientSecret}`);
-        console.log(`  tokenUrl: "${options.tokenUrl}"`);
+        if (options.clientSecret) {
+          console.log(`  clientSecret: ${options.clientSecret}`);
+        }
+        console.log(`  tokenUrl: "${resolvedTokenUrl}"`);
         console.log(`  refreshToken: "${refresh_token || "N/A (No refresh token returned)"}"`);
+        if (resolvedScopes) {
+          console.log(`  scopes: ["${resolvedScopes.split(" ").join('", "')}"]`);
+        }
         if (!refresh_token) {
           console.log('\nWarning: No refresh token was returned. Ensure your app has "offline_access" scope or similar.');
         }
@@ -3139,13 +3335,20 @@ async function handleAuth(options) {
         reject(err);
         return;
       }
-      const authUrl = new URL(options.authUrl);
+      const authUrl = new URL(resolvedAuthUrl);
       authUrl.searchParams.append("client_id", options.clientId);
       authUrl.searchParams.append("redirect_uri", redirectUri);
       authUrl.searchParams.append("response_type", "code");
       authUrl.searchParams.append("state", state);
-      if (options.scopes) {
-        authUrl.searchParams.append("scope", options.scopes);
+      if (resolvedScopes) {
+        authUrl.searchParams.append("scope", resolvedScopes);
+      }
+      if (codeChallenge) {
+        authUrl.searchParams.append("code_challenge", codeChallenge);
+        authUrl.searchParams.append("code_challenge_method", "S256");
+      }
+      if (resolvedResource) {
+        authUrl.searchParams.append("resource", resolvedResource);
       }
       console.log(`Opening browser to: ${authUrl.toString()}`);
       console.log("Waiting for callback...");
@@ -3165,15 +3368,17 @@ program.command("serve", { isDefault: true }).description("Start the Conduit ser
     process.exit(1);
   }
 });
-program.command("auth").description("Help set up OAuth for an upstream MCP server").requiredOption("--client-id <id>", "OAuth Client ID").requiredOption("--client-secret <secret>", "OAuth Client Secret").requiredOption("--auth-url <url>", "OAuth Authorization URL").requiredOption("--token-url <url>", "OAuth Token URL").option("--scopes <scopes>", "OAuth Scopes (comma separated)").option("--port <port>", "Port for the local callback server", "3333").action(async (options) => {
+program.command("auth").description("Help set up OAuth for an upstream MCP server").requiredOption("--client-id <id>", "OAuth Client ID").requiredOption("--client-secret <secret>", "OAuth Client Secret").option("--auth-url <url>", "OAuth Authorization URL").option("--token-url <url>", "OAuth Token URL").option("--mcp-url <url>", "MCP base URL (auto-discover OAuth metadata)").option("--scopes <scopes>", "OAuth Scopes (comma separated)").option("--port <port>", "Port for the local callback server", "3333").option("--pkce", "Use PKCE for the authorization code flow").action(async (options) => {
   try {
     await handleAuth({
       clientId: options.clientId,
       clientSecret: options.clientSecret,
       authUrl: options.authUrl,
       tokenUrl: options.tokenUrl,
+      mcpUrl: options.mcpUrl,
       scopes: options.scopes,
-      port: parseInt(options.port, 10)
+      port: parseInt(options.port, 10),
+      usePkce: options.pkce || Boolean(options.mcpUrl)
     });
     console.log("\nSuccess! Configuration generated.");
   } catch (err) {
@@ -3224,12 +3429,21 @@ async function startServer() {
       transport = new StdioTransport(logger, requestController, concurrencyService);
       await transport.start();
       address = "stdio";
+      const internalTransport = new SocketTransport(logger, requestController, concurrencyService);
+      const internalPort = 0;
+      const internalAddress = await internalTransport.listen({ port: internalPort });
+      executionService.ipcAddress = internalAddress;
+      const originalShutdown = transport.close.bind(transport);
+      transport.close = async () => {
+        await originalShutdown();
+        await internalTransport.close();
+      };
     } else {
       transport = new SocketTransport(logger, requestController, concurrencyService);
       const port = configService.get("port");
       address = await transport.listen({ port });
+      executionService.ipcAddress = address;
     }
-    executionService.ipcAddress = address;
     await requestController.warmup();
     logger.info("Conduit server started");
     const shutdown = async () => {