termux-dev 1.5.0 → 1.8.0

package/dist/mcp/client.js

@@ -9,6 +9,7 @@ export class MCPClient {
     buffer = '';
     tools = [];
     isConnected = false;
+    capabilities = [];
     constructor(name, config) {
         this.name = name;
         this.config = config;
@@ -17,6 +18,9 @@ export class MCPClient {
         if (this.config.disabled) {
             throw new Error(`MCP server "${this.name}" is disabled in configuration.`);
         }
+        const program = this.config.command;
+        if (!program)
+            throw new Error(`MCP server "${this.name}" has no command.`);
         return new Promise(async (resolve, reject) => {
             let isSettled = false;
             const initialTimer = setTimeout(() => {
@@ -32,11 +36,11 @@ export class MCPClient {
                     ...(this.config.env || {})
                 };
                 const isWindows = process.platform === 'win32';
-                const useShell = isWindows && (this.config.command.endsWith('.cmd') ||
-                    this.config.command.endsWith('.bat') ||
-                    this.config.command === 'npx' ||
-                    this.config.command === 'npm');
-                this.process = spawn(this.config.command, this.config.args || [], {
+                const useShell = isWindows && (program.endsWith('.cmd') ||
+                    program.endsWith('.bat') ||
+                    program === 'npx' ||
+                    program === 'npm');
+                this.process = spawn(program, this.config.args || [], {
                     env,
                     stdio: ['pipe', 'pipe', 'pipe'],
                     shell: useShell
@@ -71,6 +75,7 @@ export class MCPClient {
                     throw new Error(`Invalid initialize response from MCP server "${this.name}".`);
                 }
                 // 2. Send initialized notification
+                this.capabilities = Object.keys(initResult.capabilities || {});
                 this.sendNotification('notifications/initialized', {});
                 // 3. Fetch Tools List
                 const toolsResult = await this.sendRequest('tools/list', {});
@@ -95,6 +100,10 @@ export class MCPClient {
     getTools() {
         return this.tools;
     }
+    /** The capability groups the server announced in the handshake (tools, resources, prompts, ...). */
+    getCapabilities() {
+        return this.capabilities;
+    }
     hasConnected() {
         return this.isConnected;
     }
@@ -137,6 +146,16 @@ export class MCPClient {
                 continue;
             try {
                 const msg = JSON.parse(trimmed);
+                if (!msg || typeof msg !== 'object')
+                    continue;
+                // Messages carrying a "method" come FROM the server: a request (has an id)
+                // or a notification. Their ids live in the server's own id space and must
+                // never be matched against our pending requests.
+                if (typeof msg.method === 'string') {
+                    if (msg.id !== undefined && msg.id !== null)
+                        this.answerServerRequest(msg);
+                    continue;
+                }
                 if ('id' in msg && msg.id !== undefined) {
                     const pending = this.pendingRequests.get(msg.id);
                     if (pending) {
@@ -156,6 +175,18 @@ export class MCPClient {
             }
         }
     }
+    /** Replies to requests initiated by the server (we only support `ping`). */
+    answerServerRequest(msg) {
+        if (!this.process || !this.process.stdin)
+            return;
+        const reply = msg.method === 'ping'
+            ? { jsonrpc: '2.0', id: msg.id, result: {} }
+            : { jsonrpc: '2.0', id: msg.id, error: { code: -32601, message: `Method not found: ${msg.method}` } };
+        try {
+            this.process.stdin.write(JSON.stringify(reply) + '\n');
+        }
+        catch { }
+    }
     sendRequest(method, params, timeoutMs = 15000) {
         return new Promise((resolve, reject) => {
             if (!this.process || !this.process.stdin) {

package/dist/mcp/http-client.js

@@ -0,0 +1,174 @@
+import { DEVX_VERSION } from '../core/types.js';
+/**
+ * A remote MCP server over HTTP ("streamable HTTP": a POST per message, the answer is JSON or an
+ * event stream). Configured with `{ "url": "https://…", "headers": { "Authorization": "Bearer ${TOKEN}" } }`;
+ * `${NAME}` in a header is taken from the environment, so a token need not be written into the file.
+ * A server that needs OAuth cannot be used this way: reach it through `npx -y mcp-remote <url>`.
+ */
+export class HttpMCPClient {
+    fetchImpl;
+    name;
+    url;
+    headers;
+    sessionId = null;
+    nextId = 1;
+    tools = [];
+    capabilities = [];
+    connected = false;
+    protocolVersion = '2025-03-26';
+    constructor(name, config, fetchImpl = fetch) {
+        this.fetchImpl = fetchImpl;
+        this.name = name;
+        this.url = String(config.url);
+        this.headers = {};
+        for (const [key, value] of Object.entries(config.headers ?? {})) {
+            this.headers[key] = String(value).replace(/\$\{(\w+)\}/g, (_m, v) => process.env[v] ?? '');
+        }
+    }
+    async post(message, timeoutMs) {
+        const response = await this.fetchImpl(this.url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                accept: 'application/json, text/event-stream',
+                'mcp-protocol-version': this.protocolVersion,
+                ...(this.sessionId ? { 'mcp-session-id': this.sessionId } : {}),
+                ...this.headers,
+            },
+            body: JSON.stringify(message),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        const session = response.headers.get('mcp-session-id');
+        if (session)
+            this.sessionId = session;
+        if (response.status === 401 || response.status === 403) {
+            throw new Error(`MCP server "${this.name}" refused the request (${response.status}). It needs a token (set "headers") or OAuth: use "npx -y mcp-remote ${this.url}" as the command instead.`);
+        }
+        if (!response.ok && response.status !== 202) {
+            throw new Error(`MCP server "${this.name}" answered ${response.status} ${response.statusText}`.trim());
+        }
+        if (!('id' in message))
+            return null; // a notification: nothing to read
+        const type = response.headers.get('content-type') || '';
+        if (type.includes('text/event-stream'))
+            return this.readStream(response, message.id);
+        const body = await response.json();
+        return this.unwrap(body);
+    }
+    unwrap(body) {
+        if (body?.error)
+            throw new Error(`MCP error ${body.error.code}: ${body.error.message}`);
+        return body?.result;
+    }
+    /** Reads the events until the answer to our request arrives. */
+    async readStream(response, id) {
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error(`MCP server "${this.name}" sent an empty stream`);
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            for (;;) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                let end;
+                while ((end = buffer.search(/\r?\n\r?\n/)) !== -1) {
+                    const event = buffer.slice(0, end);
+                    buffer = buffer.slice(end).replace(/^\r?\n\r?\n/, '');
+                    const data = event.split(/\r?\n/).filter((l) => l.startsWith('data:')).map((l) => l.slice(5).replace(/^ /, '')).join('\n');
+                    if (!data)
+                        continue;
+                    try {
+                        const msg = JSON.parse(data);
+                        if (msg && msg.id === id && ('result' in msg || 'error' in msg))
+                            return this.unwrap(msg);
+                    }
+                    catch { }
+                }
+            }
+        }
+        finally {
+            try {
+                await reader.cancel();
+            }
+            catch { }
+        }
+        throw new Error(`MCP server "${this.name}" ended the stream without an answer`);
+    }
+    request(method, params, timeoutMs = 15000) {
+        return this.post({ jsonrpc: '2.0', id: this.nextId++, method, params }, timeoutMs);
+    }
+    async start() {
+        try {
+            const init = await this.request('initialize', {
+                protocolVersion: this.protocolVersion,
+                capabilities: {},
+                clientInfo: { name: 'devx', version: DEVX_VERSION },
+            });
+            if (!init)
+                throw new Error(`Invalid initialize response from MCP server "${this.name}".`);
+            if (typeof init.protocolVersion === 'string')
+                this.protocolVersion = init.protocolVersion;
+            this.capabilities = Object.keys(init.capabilities || {});
+            await this.post({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} }, 15000);
+            const tools = [];
+            let cursor;
+            for (let page = 0; page < 20; page++) {
+                const res = await this.request('tools/list', cursor ? { cursor } : {});
+                tools.push(...(res?.tools || []));
+                cursor = res?.nextCursor;
+                if (!cursor)
+                    break;
+            }
+            this.tools = tools;
+            this.connected = true;
+            return tools;
+        }
+        catch (err) {
+            this.close();
+            if (err?.name === 'TimeoutError' || err?.name === 'AbortError')
+                throw new Error(`MCP server "${this.name}" did not answer in time.`);
+            throw err;
+        }
+    }
+    getTools() {
+        return this.tools;
+    }
+    getCapabilities() {
+        return this.capabilities;
+    }
+    hasConnected() {
+        return this.connected;
+    }
+    async callTool(toolName, args) {
+        if (!this.connected)
+            throw new Error(`MCP server "${this.name}" is not connected.`);
+        const res = await this.request('tools/call', { name: toolName, arguments: args || {} }, 60000);
+        if (!res || !res.content)
+            return JSON.stringify(res || {});
+        const parts = [];
+        for (const c of res.content) {
+            if (c.type === 'text' && c.text)
+                parts.push(c.text);
+            else if (c.type === 'image' && c.data)
+                parts.push(`[Image content (${c.mimeType || 'image/png'})]`);
+            else if (c.type === 'resource')
+                parts.push(`[Resource: ${JSON.stringify(c)}]`);
+        }
+        const text = parts.join('\n\n') || JSON.stringify(res);
+        if (res.isError)
+            throw new Error(text);
+        return text;
+    }
+    close() {
+        this.connected = false;
+        if (this.sessionId) {
+            // The session is ended politely; whether the server cares is its own business.
+            const id = this.sessionId;
+            this.sessionId = null;
+            void this.fetchImpl(this.url, { method: 'DELETE', headers: { 'mcp-session-id': id, ...this.headers }, signal: AbortSignal.timeout(3000) }).catch(() => { });
+        }
+    }
+}