@mhingston5/conduit 1.1.1 → 1.1.3

package/README.md

@@ -21,7 +21,7 @@ Conduit is a **secure Code Mode execution substrate** for [MCP](https://modelcon
 
 It lets agents:
 - generate **real TypeScript or Python code**
-- call tools via **language-native APIs** (`tools.github.createIssue()`)
+- call tools via **language-native APIs** (`tools.github.create_issue()`)
 - run that code in **isolated, resource-governed sandboxes**
 - without exposing credentials or the host environment
 
@@ -66,6 +66,15 @@ upstreams:
   - id: github
     type: http
     url: "http://localhost:3000/mcp"
+  - id: slack
+    type: http
+    url: "https://your-mcp-server/mcp"
+    credentials:
+      type: oauth2
+      clientId: ${SLACK_CLIENT_ID}
+      clientSecret: ${SLACK_CLIENT_SECRET}
+      tokenUrl: "https://slack.com/api/oauth.v2.access"
+      refreshToken: ${SLACK_REFRESH_TOKEN}
     # Or use local stdio for testing:
   - id: filesystem
     type: stdio
@@ -73,9 +82,24 @@ upstreams:
     args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
 ```
 
-### 3. Execute TypeScript
+### 3. OAuth Setup Helper
+
+If your upstream requires an initial OAuth flow (like Jira), you can use the built-in helper to obtain a refresh token:
+
+```bash
+npx conduit auth \
+  --client-id <id> \
+  --client-secret <secret> \
+  --auth-url <url> \
+  --token-url <url> \
+  --scopes <scopes>
+```
+
+This will start a temporary local server, open your browser for authorization, and print the generated `credentials` block for your `conduit.yaml`.
+
+### 4. Execute TypeScript
 
-Using any [MCP Client](https://modelcontextprotocol.io/clients) (Claude Desktop, etc.), call `mcp.executeTypeScript`:
+Using any [MCP Client](https://modelcontextprotocol.io/clients) (Claude Desktop, etc.), call `mcp_execute_typescript`:
 
 ```ts
 // The agent writes this code:
@@ -83,7 +107,7 @@ const result = await tools.filesystem.list_allowed_directories();
 console.log("Files:", result);
 ```
 
-### 4. Result
+### 5. Result
 
 Conduit runs the code, handles the tool call securely, and returns:
 
@@ -182,7 +206,7 @@ To get the most out of Conduit, you should guide your LLM (agent) to prefer mult
 **Recommended System Prompt Additions:**
 > You are equipped with a "Code Mode" execution environment via Conduit.
 >
-> - **Prefer `mcp.executeTypeScript`**: Use this for any task requiring multiple steps, data transformation, or logical branching.
+> - **Prefer `mcp_execute_typescript`**: Use this for any task requiring multiple steps, data transformation, or logical branching.
 > - **Use `tools.*` SDK**: Within your scripts, access all upstream tools via the `tools` namespace (e.g., `await tools.github.create_issue(...)`).
 > - **Avoid JSON tool-calling overhead**: Instead of making 5 separate tool calls and waiting for 5 round-trips, write one script that orchestrates the entire operation.
 > - **Data Transformation**: Perform loops, filters, and aggregations directly in your code rather than asking the user (or yourself) to process large datasets in the chat context.

package/dist/assets/deno-shim.ts

@@ -0,0 +1,93 @@
+// @ts-nocheck
+// Deno Shim for Conduit - Code Mode SDK
+const IPC_ADDRESS = '__CONDUIT_IPC_ADDRESS__';
+const IPC_TOKEN = '__CONDUIT_IPC_TOKEN__';
+
+async function sendIPCRequest(method: string, params: any) {
+    if (!IPC_ADDRESS) throw new Error('Conduit IPC address not configured');
+
+    let conn: any;
+    try {
+        if (IPC_ADDRESS.includes(':')) {
+            const lastColon = IPC_ADDRESS.lastIndexOf(':');
+            const hostname = IPC_ADDRESS.substring(0, lastColon);
+            const port = IPC_ADDRESS.substring(lastColon + 1);
+
+            // Normalize hostname for Deno connect
+            let targetHost = hostname.replace(/[\[\]]/g, '');
+            if (targetHost === '0.0.0.0' || targetHost === '::' || targetHost === '::1' || targetHost === '') {
+                targetHost = '127.0.0.1';
+            }
+
+            conn = await (Deno as any).connect({
+                hostname: targetHost,
+                port: Number(port)
+            });
+        } else {
+            conn = await (Deno as any).connect({ transport: 'unix', path: IPC_ADDRESS });
+        }
+    } catch (err: any) {
+        throw new Error(`Failed to connect to Conduit IPC (${IPC_ADDRESS}): ${err.message}`);
+    }
+
+    try {
+        const id = Math.random().toString(36).substring(7);
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params: params || {},
+            auth: { bearerToken: IPC_TOKEN }
+        };
+
+        const encoder = new TextEncoder();
+        await conn.write(encoder.encode(JSON.stringify(request) + '\n'));
+
+        const decoder = new TextDecoder();
+        let buffer = '';
+        const chunk = new Uint8Array(2 * 1024 * 1024); // 2MB buffer for large tool returns
+
+        while (true) {
+            const n = await conn.read(chunk);
+            if (n === null) throw new Error('IPC connection closed by host before receiving response');
+
+            buffer += decoder.decode(chunk.subarray(0, n));
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || ''; // Keep partial line
+
+            for (const line of lines) {
+                if (!line.trim()) continue;
+                try {
+                    const response = JSON.parse(line);
+                    if (response.id === id) {
+                        if (response.error) {
+                            const error = new Error(response.error.message);
+                            (error as any).code = response.error.code;
+                            (error as any).data = response.error.data;
+                            throw error;
+                        }
+                        return response.result;
+                    }
+                } catch (e: any) {
+                    if (e.message.includes('JSON')) continue;
+                    throw e;
+                }
+            }
+        }
+    } finally {
+        conn.close();
+    }
+}
+
+// Internal tool call function - used by generated SDK
+const __internalCallTool = async (name: string, params: any) => {
+    return await sendIPCRequest('mcp_call_tool', { name, arguments: params });
+};
+
+// Tool discovery - still available for dynamic scenarios
+(globalThis as any).discoverMCPTools = async (options: any) => {
+    const result = await sendIPCRequest('mcp_discover_tools', options);
+    return result.tools || [];
+};
+
+// __CONDUIT_SDK_INJECTION__

package/dist/assets/python-shim.py

@@ -0,0 +1,21 @@
+# Python Shim for Conduit - Code Mode SDK
+import asyncio
+
+async def discover_mcp_tools(options=None):
+    """Discover available MCP tools from the gateway."""
+    # These functions are injected into the Python global scope by the executor
+    res = await discover_mcp_tools_js(options)
+    # Pyodide's JS proxy handles conversion broadly, but we might need to convert the tools list
+    if hasattr(res, 'to_py'):
+        data = res.to_py()
+        return data.get('tools', []) if isinstance(data, dict) else []
+    return []
+
+async def _internal_call_tool(name, arguments):
+    """Internal tool call function - used by generated SDK."""
+    res = await call_mcp_tool_js(name, arguments)
+    if hasattr(res, 'to_py'):
+        return res.to_py()
+    return res
+
+# __CONDUIT_SDK_INJECTION__

package/dist/executors/pyodide.worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/executors/pyodide.worker.js

@@ -0,0 +1,163 @@
+// src/executors/pyodide.worker.ts
+import { parentPort } from "worker_threads";
+import { loadPyodide } from "pyodide";
+import net from "net";
+var pyodide = null;
+var currentStdout = "";
+var currentStderr = "";
+var totalOutputBytes = 0;
+var totalLogEntries = 0;
+var currentLimits = null;
+async function init() {
+  if (pyodide) return pyodide;
+  pyodide = await loadPyodide({
+    stdout: (text) => {
+      if (currentLimits && (totalOutputBytes > (currentLimits.maxOutputBytes || 1024 * 1024) || totalLogEntries > (currentLimits.maxLogEntries || 1e4))) {
+        return;
+      }
+      currentStdout += text + "\n";
+      totalOutputBytes += text.length + 1;
+      totalLogEntries++;
+    },
+    stderr: (text) => {
+      if (currentLimits && (totalOutputBytes > (currentLimits.maxOutputBytes || 1024 * 1024) || totalLogEntries > (currentLimits.maxLogEntries || 1e4))) {
+        return;
+      }
+      currentStderr += text + "\n";
+      totalOutputBytes += text.length + 1;
+      totalLogEntries++;
+    }
+  });
+  return pyodide;
+}
+async function handleTask(data) {
+  const { code, limits, ipcInfo, shim } = data;
+  currentStdout = "";
+  currentStderr = "";
+  totalOutputBytes = 0;
+  totalLogEntries = 0;
+  currentLimits = limits;
+  try {
+    const p = await init();
+    const sendIPCRequest = async (method, params) => {
+      if (!ipcInfo?.ipcAddress) throw new Error("Conduit IPC address not configured");
+      return new Promise((resolve, reject) => {
+        let client;
+        if (ipcInfo.ipcAddress.includes(":")) {
+          const lastColon = ipcInfo.ipcAddress.lastIndexOf(":");
+          const host = ipcInfo.ipcAddress.substring(0, lastColon);
+          const port = ipcInfo.ipcAddress.substring(lastColon + 1);
+          let targetHost = host.replace(/[\[\]]/g, "");
+          if (targetHost === "0.0.0.0" || targetHost === "::" || targetHost === "::1" || targetHost === "") {
+            targetHost = "127.0.0.1";
+          }
+          client = net.createConnection({
+            host: targetHost,
+            port: parseInt(port)
+          });
+        } else {
+          client = net.createConnection({ path: ipcInfo.ipcAddress });
+        }
+        const id = Math.random().toString(36).substring(7);
+        const request = {
+          jsonrpc: "2.0",
+          id,
+          method,
+          params: params || {},
+          auth: { bearerToken: ipcInfo.ipcToken }
+        };
+        client.on("error", (err) => {
+          reject(err);
+          client.destroy();
+        });
+        client.write(JSON.stringify(request) + "\n");
+        let buffer = "";
+        client.on("data", (data2) => {
+          buffer += data2.toString();
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const response = JSON.parse(line);
+              if (response.id === id) {
+                if (response.error) {
+                  reject(new Error(response.error.message));
+                } else {
+                  resolve(response.result);
+                }
+                client.end();
+                return;
+              }
+            } catch (e) {
+            }
+          }
+        });
+        client.on("end", () => {
+          if (buffer.trim()) {
+            try {
+              const response = JSON.parse(buffer);
+              if (response.id === id) {
+                if (response.error) {
+                  reject(new Error(response.error.message));
+                } else {
+                  resolve(response.result);
+                }
+              }
+            } catch (e) {
+            }
+          }
+        });
+      });
+    };
+    p.globals.set("discover_mcp_tools_js", (options) => {
+      return sendIPCRequest("mcp_discover_tools", options);
+    });
+    p.globals.set("call_mcp_tool_js", (name, args) => {
+      return sendIPCRequest("mcp_call_tool", { name, arguments: args });
+    });
+    if (shim) {
+      await p.runPythonAsync(shim);
+    }
+    const result = await p.runPythonAsync(code);
+    if (totalOutputBytes > (limits.maxOutputBytes || 1024 * 1024)) {
+      throw new Error("[LIMIT_OUTPUT]");
+    }
+    if (totalLogEntries > (limits.maxLogEntries || 1e4)) {
+      throw new Error("[LIMIT_LOG]");
+    }
+    parentPort?.postMessage({
+      stdout: currentStdout,
+      stderr: currentStderr,
+      result: String(result),
+      success: true
+    });
+  } catch (err) {
+    let isOutput = err.message.includes("[LIMIT_OUTPUT]");
+    let isLog = err.message.includes("[LIMIT_LOG]");
+    if (!isOutput && !isLog && currentLimits) {
+      if (totalOutputBytes > (currentLimits.maxOutputBytes || 1024 * 1024)) {
+        isOutput = true;
+      }
+      if (totalLogEntries > (currentLimits.maxLogEntries || 1e4)) {
+        isLog = true;
+      }
+    }
+    parentPort?.postMessage({
+      stdout: currentStdout,
+      stderr: currentStderr,
+      error: err.message,
+      limitBreached: isOutput ? "output" : isLog ? "log" : void 0,
+      success: false
+    });
+  }
+}
+parentPort?.on("message", async (msg) => {
+  if (msg.type === "execute") {
+    await handleTask(msg.data);
+  } else if (msg.type === "ping") {
+    parentPort?.postMessage({ type: "pong" });
+  }
+});
+parentPort?.postMessage({ type: "ready" });
+//# sourceMappingURL=pyodide.worker.js.map

package/dist/executors/pyodide.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/executors/pyodide.worker.ts"],"sourcesContent":["import { parentPort, workerData } from 'node:worker_threads';\nimport { loadPyodide, type PyodideInterface } from 'pyodide';\nimport net from 'node:net';\n\nlet pyodide: PyodideInterface | null = null;\nlet currentStdout = '';\nlet currentStderr = '';\nlet totalOutputBytes = 0;\nlet totalLogEntries = 0;\nlet currentLimits: any = null;\n\nasync function init() {\n    if (pyodide) return pyodide;\n\n    pyodide = await loadPyodide({\n        stdout: (text) => {\n            if (currentLimits && (totalOutputBytes > (currentLimits.maxOutputBytes || 1024 * 1024) || totalLogEntries > (currentLimits.maxLogEntries || 10000))) {\n                return; // Stop processing logs once limit breached\n            }\n            currentStdout += text + '\\n';\n            totalOutputBytes += text.length + 1;\n            totalLogEntries++;\n        },\n        stderr: (text) => {\n            if (currentLimits && (totalOutputBytes > (currentLimits.maxOutputBytes || 1024 * 1024) || totalLogEntries > (currentLimits.maxLogEntries || 10000))) {\n                return; // Stop processing logs once limit breached\n            }\n            currentStderr += text + '\\n';\n            totalOutputBytes += text.length + 1;\n            totalLogEntries++;\n        },\n    });\n\n    return pyodide;\n}\n\nasync function handleTask(data: any) {\n    const { code, limits, ipcInfo, shim } = data;\n    currentStdout = '';\n    currentStderr = '';\n    totalOutputBytes = 0;\n    totalLogEntries = 0;\n    currentLimits = limits;\n\n    try {\n        const p = await init();\n\n        const sendIPCRequest = async (method: string, params: any) => {\n            if (!ipcInfo?.ipcAddress) throw new Error('Conduit IPC address not configured');\n\n            return new Promise((resolve, reject) => {\n                let client: net.Socket;\n\n                if (ipcInfo.ipcAddress.includes(':')) {\n                    const lastColon = ipcInfo.ipcAddress.lastIndexOf(':');\n                    const host = ipcInfo.ipcAddress.substring(0, lastColon);\n                    const port = ipcInfo.ipcAddress.substring(lastColon + 1);\n\n                    let targetHost = host.replace(/[\\[\\]]/g, '');\n                    if (targetHost === '0.0.0.0' || targetHost === '::' || targetHost === '::1' || targetHost === '') {\n                        targetHost = '127.0.0.1';\n                    }\n\n                    client = net.createConnection({\n                        host: targetHost,\n                        port: parseInt(port)\n                    });\n                } else {\n                    client = net.createConnection({ path: ipcInfo.ipcAddress });\n                }\n\n                const id = Math.random().toString(36).substring(7);\n                const request = {\n                    jsonrpc: '2.0',\n                    id,\n                    method,\n                    params: params || {},\n                    auth: { bearerToken: ipcInfo.ipcToken }\n                };\n\n                client.on('error', (err) => {\n                    reject(err);\n                    client.destroy();\n                });\n\n                client.write(JSON.stringify(request) + '\\n');\n\n                let buffer = '';\n                client.on('data', (data) => {\n                    buffer += data.toString();\n                    // Robust framing: read until we find a complete JSON object on a line\n                    const lines = buffer.split('\\n');\n                    buffer = lines.pop() || ''; // Keep the last partial line\n\n                    for (const line of lines) {\n                        if (!line.trim()) continue;\n                        try {\n                            const response = JSON.parse(line);\n                            if (response.id === id) {\n                                if (response.error) {\n                                    reject(new Error(response.error.message));\n                                } else {\n                                    resolve(response.result);\n                                }\n                                client.end();\n                                return;\n                            }\n                        } catch (e) {\n                            // If parse fails, it might be a partial line that we haven't seen the end of yet\n                            // but since we split by \\n, this shouldn't happen unless the \\n was inside the JSON.\n                            // However, Conduit ensures JSON-RPC is one line.\n                        }\n                    }\n                });\n\n                client.on('end', () => {\n                    if (buffer.trim()) {\n                        try {\n                            const response = JSON.parse(buffer);\n                            if (response.id === id) {\n                                if (response.error) {\n                                    reject(new Error(response.error.message));\n                                } else {\n                                    resolve(response.result);\n                                }\n                            }\n                        } catch (e) { }\n                    }\n                });\n            });\n        };\n\n        (p as any).globals.set('discover_mcp_tools_js', (options: any) => {\n            return sendIPCRequest('mcp_discover_tools', options);\n        });\n\n        (p as any).globals.set('call_mcp_tool_js', (name: string, args: any) => {\n            return sendIPCRequest('mcp_call_tool', { name, arguments: args });\n        });\n\n        if (shim) {\n            await p.runPythonAsync(shim);\n        }\n\n        const result = await p.runPythonAsync(code);\n\n        if (totalOutputBytes > (limits.maxOutputBytes || 1024 * 1024)) {\n            throw new Error('[LIMIT_OUTPUT]');\n        }\n        if (totalLogEntries > (limits.maxLogEntries || 10000)) {\n            throw new Error('[LIMIT_LOG]');\n        }\n\n        parentPort?.postMessage({\n            stdout: currentStdout,\n            stderr: currentStderr,\n            result: String(result),\n            success: true,\n        });\n    } catch (err: any) {\n        let isOutput = err.message.includes('[LIMIT_OUTPUT]');\n        let isLog = err.message.includes('[LIMIT_LOG]');\n\n        // Fallback: check counters if message doesn't match (e.g. wrapped in OSError)\n        if (!isOutput && !isLog && currentLimits) {\n            if (totalOutputBytes > (currentLimits.maxOutputBytes || 1024 * 1024)) {\n                isOutput = true;\n            }\n            // Check specific log limit breach\n            if (totalLogEntries > (currentLimits.maxLogEntries || 10000)) {\n                isLog = true;\n            }\n        }\n\n        parentPort?.postMessage({\n            stdout: currentStdout,\n            stderr: currentStderr,\n            error: err.message,\n            limitBreached: isOutput ? 'output' : (isLog ? 'log' : undefined),\n            success: false,\n        });\n    }\n}\n\nparentPort?.on('message', async (msg) => {\n    if (msg.type === 'execute') {\n        await handleTask(msg.data);\n    } else if (msg.type === 'ping') {\n        parentPort?.postMessage({ type: 'pong' });\n    }\n});\n\n// Signal ready\nparentPort?.postMessage({ type: 'ready' });\n\n"],"mappings":"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","names":["data"]}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }