@sghanavati/relay-mcp 0.1.4 → 0.1.6

package/README.md

@@ -3,9 +3,9 @@
 [![Node.js](https://img.shields.io/node/v/@sghanavati/relay-mcp.svg)](https://nodejs.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-MCP server that lets Claude Code delegate coding tasks to Codex.
+MCP server that lets Claude Code delegate work to Codex, OpenRouter, and LM Studio through one MCP tool.
 
-> **Prerequisites:** Codex CLI >= 0.39.0 must be installed (`npm install -g @openai/codex`) and authenticated (`codex login`).
+> **Prerequisites:** For `provider: "codex"`, install Codex CLI >= 0.39.0 (`npm install -g @openai/codex`) and authenticate (`codex login`). For `provider: "openrouter"` set `OPENROUTER_API_KEY`. For `provider: "lmstudio"` run LM Studio and set `LMSTUDIO_ENDPOINT` if needed.
 
 ## Quick Start
 Add this to your Claude Code `.mcp.json`, then restart Claude Code:
@@ -27,7 +27,7 @@ Add this to your Claude Code `.mcp.json`, then restart Claude Code:
 
 - No global install of `relay-mcp` is required.
 - `npx -y @sghanavati/relay-mcp` downloads and runs the published package directly.
-- You only need to keep Codex CLI installed and authenticated locally.
+- You need provider-specific runtime setup (Codex CLI for `codex`, API key for `openrouter`, local endpoint for `lmstudio`).
 
 ## Claude Code Registration
 ### npx (recommended)
@@ -133,7 +133,9 @@ Typical response payload:
     "warnings": [],
     "model": null,
     "token_estimate": 1200,
-    "exit_code": 0
+    "exit_code": 0,
+    "provider": "codex",
+    "log_file": "~/.relay-mcp/run-<hash>.log"
   }
 }
 ```
@@ -226,22 +228,45 @@ tmux window
 
 **The loop:**
 1. CC writes a plan (GSD), then fires `delegate` calls — one per task
-2. relay-mcp spawns Codex for each and returns `files_changed` + output when done
-3. *(Phase 3)* Each task streams output to a log file; adjacent panes `tail -f` those logs live
-4. CC reads `files_changed`, verifies output, moves to the next task
-5. You supervise only CC — Codex runs unattended
-
-> **Note:** Live log streaming (`meta.log_file`) lands in Phase 3. Steps 1, 2, 4, and 5 work today.
+2. relay-mcp executes each call with the selected provider and returns `files_changed` + output
+3. Each task writes to a provider run log file (`meta.log_file`); adjacent panes can `tail -f` logs live
+4. CC reads `files_changed` and output, verifies results, then moves to the next task
+5. You supervise only CC while providers run unattended
 
 ## Configuration
 | Variable | Default | Description |
 | --- | --- | --- |
 | `RELAY_CODEX_PATH` | `codex` from `PATH` | Full path to Codex binary for PATH-limited environments (especially Claude Desktop). |
 | `RELAY_LOG_LEVEL` | `info` | Startup log verbosity control. `error` suppresses the ready banner; other values show it. |
+| `RELAY_ALLOWED_ROOTS` | unset | Optional allowlist for delegate `workdir`. Path-delimited list (`:` on macOS/Linux, `;` on Windows). If set, workdirs outside these roots are rejected. |
+| `RELAY_SKIP_GIT_CHECK` | `0` | Set to `1` to add `--skip-git-repo-check` to Codex runs. Default keeps repo check enabled. |
+| `OPENROUTER_API_KEY` | unset | Required for `provider: "openrouter"`. |
+| `LMSTUDIO_ENDPOINT` | `http://localhost:1234` | Base URL for LM Studio OpenAI-compatible server. |
+| `LMSTUDIO_API_KEY` | unset | Optional bearer token for LM Studio endpoint. |
 
 ### Provider model requirement
 - `provider: "codex"`: `model` is optional.
 - `provider: "openrouter"` or `provider: "lmstudio"`: `model` is required.
+- `provider: "openrouter"` and `provider: "lmstudio"` are generation-only and always return `files_changed: []`.
+
+### Provider examples
+```javascript
+delegate({
+  provider: "openrouter",
+  model: "google/gemini-2.5-pro",
+  task: "Review this implementation and return a concise risk list",
+  workdir: "/path/to/repo"
+});
+```
+
+```javascript
+delegate({
+  provider: "lmstudio",
+  model: "qwen2.5-coder-32b-instruct",
+  task: "Draft unit tests for src/auth.ts",
+  workdir: "/path/to/repo"
+});
+```
 
 ## Troubleshooting
 ### 1) PATH issues (Codex not found)
@@ -278,7 +303,15 @@ Fix:
 - Confirm network/DNS connectivity and any proxy requirements.
 - Re-run `codex login` if your session may have expired.
 
-### 4) `npx` from this package's own repo root
+### 4) Missing model for OpenRouter or LM Studio
+Symptom:
+`status: "error"` with `error.code: "INVALID_ARGS"` and message that model is required.
+
+Fix:
+- Add `model` whenever `provider` is `openrouter` or `lmstudio`.
+- Example: `model: "google/gemini-2.5-pro"` for OpenRouter.
+
+### 5) `npx` from this package's own repo root
 Symptom:
 `sh: relay-mcp: command not found` when running `npx -y @sghanavati/relay-mcp` from inside the `relay-mcp` source checkout.
 
@@ -288,9 +321,11 @@ Fix:
 - For published-package verification, run from any other directory (or use `npm --prefix /tmp exec --yes --package=@sghanavati/relay-mcp -- relay-mcp --version`).
 
 ## Security
-- `relay-mcp` only delegates work inside the `workdir` you pass to `delegate`.
 - `workdir` values are canonicalized with `path.resolve()` before subprocess execution.
-- Codex runs with `--full-auto` and can read/write files in that delegated directory.
+- Optional `RELAY_ALLOWED_ROOTS` enforces an explicit allowlist for delegate `workdir`.
+- Codex runs with `--full-auto` and can read/write files in the delegated directory.
+- `--skip-git-repo-check` is disabled by default and only enabled when `RELAY_SKIP_GIT_CHECK=1`.
+- Run/event logs are written under `~/.relay-mcp` (directory mode `700`, file mode `600` best-effort).
 - `relay-mcp` does not store credentials, API keys, or session tokens; authentication remains in Codex CLI.
 
 ## License

package/dist/config/providers.js

@@ -1,3 +1,11 @@
+export const SUPPORTED_PROVIDERS = ["codex", "openrouter", "lmstudio"];
+export const DEFAULT_PROVIDER = "codex";
+export function isSupportedProvider(provider) {
+    return SUPPORTED_PROVIDERS.includes(provider);
+}
+export function isAgenticProvider(provider) {
+    return provider === "codex";
+}
 export function getOpenRouterApiKey() {
     return process.env["OPENROUTER_API_KEY"]?.trim() || null;
 }

package/dist/contracts/delegate.js

@@ -1,11 +1,12 @@
 import { z } from "zod";
+import { DEFAULT_PROVIDER, SUPPORTED_PROVIDERS } from "../config/providers.js";
 const delegateSchemaShape = {
     task: z.string().min(1).describe("The coding task to delegate to the worker"),
     workdir: z.string().describe("Absolute path to the working directory"),
     provider: z
-        .enum(["codex", "openrouter", "lmstudio"])
+        .enum(SUPPORTED_PROVIDERS)
         .optional()
-        .default("codex")
+        .default(DEFAULT_PROVIDER)
         .describe("Worker provider. 'codex' = agentic execution (modifies files). " +
         "'openrouter' and 'lmstudio' = generation-only (text response, no file changes)."),
     context: z

package/dist/telemetry/run-event.js

@@ -1,8 +1,28 @@
-import { appendFileSync } from "node:fs";
-export const RELAY_EVENTS_LOG = "/tmp/relay-mcp-events.jsonl";
+import { appendFileSync, chmodSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function relayDir() {
+    const dir = join(homedir(), ".relay-mcp");
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(dir, 0o700);
+    }
+    catch {
+        /* best-effort */
+    }
+    return dir;
+}
+export const RELAY_EVENTS_LOG = join(homedir(), ".relay-mcp", "events.jsonl");
 export function writeRunEvent(event, logPath = RELAY_EVENTS_LOG) {
     try {
+        relayDir();
         appendFileSync(logPath, JSON.stringify(event) + "\n");
+        try {
+            chmodSync(logPath, 0o600);
+        }
+        catch {
+            /* best-effort */
+        }
     }
     catch {
         // Best-effort — never crash the server over a log write.

package/dist/tools/check_workers.js

@@ -1,15 +1,25 @@
-import { diagnoseCodexWorker } from "../workers/diagnostics.js";
+import { diagnoseCodexWorker, diagnoseLmStudioWorker, diagnoseOpenRouterWorker, } from "../workers/diagnostics.js";
 export async function handleCheckWorkers() {
-    const codexDiagRaw = await diagnoseCodexWorker();
-    const codexDiag = {
-        worker: codexDiagRaw.worker,
-        available: codexDiagRaw.available,
-        reason: codexDiagRaw.reason,
-        remediation: codexDiagRaw.remediation,
-    };
+    const [codexDiagRaw, openRouterDiagRaw, lmStudioDiagRaw] = await Promise.all([
+        diagnoseCodexWorker(),
+        diagnoseOpenRouterWorker(),
+        diagnoseLmStudioWorker(),
+    ]);
+    const codexDiag = toWorkerDiagnostic(codexDiagRaw);
+    const openRouterDiag = toWorkerDiagnostic(openRouterDiagRaw);
+    const lmStudioDiag = toWorkerDiagnostic(lmStudioDiagRaw);
+    const workers = [codexDiag, openRouterDiag, lmStudioDiag];
     const result = {
-        workers: [codexDiag],
-        all_available: codexDiag.available,
+        workers,
+        all_available: workers.every((worker) => worker.available),
     };
     return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
 }
+function toWorkerDiagnostic(diagnostic) {
+    return {
+        worker: diagnostic.worker,
+        available: diagnostic.available,
+        reason: diagnostic.reason,
+        remediation: diagnostic.remediation,
+    };
+}

package/dist/tools/delegate.js

@@ -1,7 +1,10 @@
 import * as path from "node:path";
+import { execFileSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
-import { createWriteStream, readFileSync } from "node:fs";
+import { chmodSync, createWriteStream, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { join } from "node:path";
+import { DEFAULT_PROVIDER, isAgenticProvider as providerIsAgentic, isSupportedProvider, } from "../config/providers.js";
 import { DEFAULT_TIMEOUT_MS, TOKEN_HARD_CAP, TOKEN_WARN_THRESHOLD } from "../config/constants.js";
 import { makeError } from "../errors.js";
 import { getWorkdirMutex } from "../concurrency/index.js";
@@ -14,13 +17,32 @@ function normalizeWorkdir(rawWorkdir) {
 }
 function computeLogPath(workdir) {
     const hash = createHash("sha1").update(workdir).digest("hex").slice(0, 8);
-    return `/tmp/relay-mcp-${hash}.log`;
+    return path.join(homedir(), ".relay-mcp", `run-${hash}.log`);
+}
+function parseAllowedRoots(raw) {
+    return raw
+        .split(path.delimiter)
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0)
+        .map((segment) => path.resolve(segment));
 }
 /**
- * Resolve AGENTS.md from workdir upward to filesystem root.
+ * Resolve AGENTS.md from workdir upward to git root (when inside a repo),
+ * otherwise to filesystem root.
  * Nearest non-empty file wins.
  */
 export function readNearestAgentsMd(workdir) {
+    let gitRoot = null;
+    try {
+        gitRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            cwd: workdir,
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf8",
+        }).trim();
+    }
+    catch {
+        gitRoot = null;
+    }
     let current = path.resolve(workdir);
     while (true) {
         try {
@@ -35,6 +57,8 @@ export function readNearestAgentsMd(workdir) {
         if (parent === current)
             return null;
         current = parent;
+        if (gitRoot !== null && !current.startsWith(gitRoot))
+            return null;
     }
 }
 function buildDelegateMeta(params) {
@@ -84,7 +108,7 @@ function normalizeThrownError(err) {
     return makeError("UNKNOWN", `Unexpected worker error: ${String(err)}`, false);
 }
 export async function handleDelegate(args) {
-    const { task, workdir: rawWorkdir, context, timeout_ms, model, provider = "codex" } = args;
+    const { task, workdir: rawWorkdir, context, timeout_ms, model, provider = DEFAULT_PROVIDER } = args;
     const modelOverride = model?.trim() ? model.trim() : undefined;
     const run_id = randomUUID();
     const queued_at = Date.now();
@@ -97,10 +121,36 @@ export async function handleDelegate(args) {
         parts.push(context);
     parts.push(task);
     const finalTask = parts.join("\n\n");
-    const knownProviders = new Set(["codex", "openrouter", "lmstudio"]);
-    const isKnownProvider = knownProviders.has(provider);
-    const isAgenticProvider = provider === "codex";
+    const isKnownProvider = isSupportedProvider(provider);
+    const isAgenticProvider = isKnownProvider && providerIsAgentic(provider);
     const logPath = computeLogPath(workdir);
+    const allowedRootsRaw = process.env["RELAY_ALLOWED_ROOTS"]?.trim();
+    if (allowedRootsRaw) {
+        const roots = parseAllowedRoots(allowedRootsRaw);
+        const allowed = roots.some((root) => workdir === root || workdir.startsWith(root + path.sep));
+        if (!allowed) {
+            const response = {
+                status: "error",
+                output: "",
+                files_changed: [],
+                meta: buildDelegateMeta({
+                    duration_ms: 0,
+                    truncated: false,
+                    warnings: [],
+                    model: modelOverride,
+                    token_estimate: 0,
+                    exit_code: null,
+                    log_file: logPath,
+                    run_id,
+                    provider,
+                    spawn_time_ms: 0,
+                    token_usage: null,
+                }),
+                error: makeError("WORKDIR_NOT_FOUND", `workdir "${workdir}" is not under any allowed root. Set RELAY_ALLOWED_ROOTS to permit it.`, false),
+            };
+            return toMcpResult(response);
+        }
+    }
     if (!isKnownProvider) {
         const response = {
             status: "error",
@@ -152,7 +202,21 @@ export async function handleDelegate(args) {
         release = await getWorkdirMutex(workdir).acquire();
         preSnapshot = await takeSnapshot(workdir);
     }
+    const logDir = path.dirname(logPath);
+    mkdirSync(logDir, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(logDir, 0o700);
+    }
+    catch {
+        /* best-effort */
+    }
     const logStream = createWriteStream(logPath, { flags: "a" });
+    try {
+        chmodSync(logPath, 0o600);
+    }
+    catch {
+        /* best-effort */
+    }
     logStream.on("error", () => {
         /* swallow write errors - log is best-effort */
     });

package/dist/workers/codex.js

@@ -20,13 +20,20 @@ export function parseCodexLine(line) {
     }
     return null;
 }
-export async function runCodexWorker(task) {
-    const startTime = Date.now();
-    const codexBin = getCodexBin();
-    const args = ["exec", "--cd", task.workdir, "--json", "--full-auto", "--skip-git-repo-check"];
+/** Pure function for argument construction - exported for testing */
+export function buildCodexArgs(task, env = process.env) {
+    const args = ["exec", "--cd", task.workdir, "--json", "--full-auto"];
+    if (env["RELAY_SKIP_GIT_CHECK"] === "1")
+        args.push("--skip-git-repo-check");
     if (task.model)
         args.push("--model", task.model);
     args.push(task.task);
+    return args;
+}
+export async function runCodexWorker(task) {
+    const startTime = Date.now();
+    const codexBin = getCodexBin();
+    const args = buildCodexArgs(task);
     const child = spawn(codexBin, args, {
         stdio: ["pipe", "pipe", "pipe"],
         env: { ...process.env },

package/dist/workers/diagnostics.js

@@ -1,9 +1,11 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { MIN_CODEX_VERSION } from "../config/constants.js";
+import { getLmStudioEndpoint, getOpenRouterApiKey, } from "../config/providers.js";
 import { getCodexBin } from "../config/runtime.js";
 import { formatVersionTriplet, isVersionBelow } from "../utils/version.js";
 const execFileAsync = promisify(execFile);
+const LMSTUDIO_TIMEOUT_MS = 3_000;
 export async function diagnoseCodexWorker() {
     const codexBin = getCodexBin();
     const configuredPath = process.env.RELAY_CODEX_PATH?.trim();
@@ -54,3 +56,79 @@ export async function diagnoseCodexWorker() {
         remediation: "",
     };
 }
+export async function diagnoseOpenRouterWorker() {
+    const apiKey = getOpenRouterApiKey();
+    if (!apiKey) {
+        return {
+            worker: "openrouter",
+            available: false,
+            reason: "OPENROUTER_API_KEY is not set",
+            remediation: "Set OPENROUTER_API_KEY in your MCP config env",
+        };
+    }
+    return {
+        worker: "openrouter",
+        available: true,
+        reason: "OPENROUTER_API_KEY is set",
+        remediation: "",
+    };
+}
+export async function diagnoseLmStudioWorker() {
+    const endpoint = getLmStudioEndpoint().replace(/\/+$/, "");
+    const modelsUrl = `${endpoint}/v1/models`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), LMSTUDIO_TIMEOUT_MS);
+    try {
+        const response = await fetch(modelsUrl, {
+            method: "GET",
+            signal: controller.signal,
+        });
+        if (response.status === 200) {
+            return {
+                worker: "lmstudio",
+                available: true,
+                reason: `LM Studio reachable at ${modelsUrl}`,
+                remediation: "",
+            };
+        }
+        return {
+            worker: "lmstudio",
+            available: false,
+            reason: `LM Studio responded with HTTP ${response.status} at ${modelsUrl}`,
+            remediation: "Start LM Studio's local server or set LMSTUDIO_ENDPOINT in your MCP config env",
+        };
+    }
+    catch (error) {
+        const errorCode = getErrorCode(error);
+        let reason = `LM Studio request failed at ${modelsUrl}`;
+        if (error instanceof Error && error.name === "AbortError") {
+            reason = `LM Studio request to ${modelsUrl} timed out after ${LMSTUDIO_TIMEOUT_MS}ms`;
+        }
+        else if (errorCode === "ECONNREFUSED") {
+            reason = `LM Studio connection refused at ${modelsUrl}`;
+        }
+        else if (error instanceof Error && error.message) {
+            reason = `LM Studio request failed at ${modelsUrl}: ${error.message}`;
+        }
+        return {
+            worker: "lmstudio",
+            available: false,
+            reason,
+            remediation: "Start LM Studio's local server or set LMSTUDIO_ENDPOINT in your MCP config env",
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function getErrorCode(error) {
+    if (!error || typeof error !== "object" || !("cause" in error)) {
+        return null;
+    }
+    const cause = error.cause;
+    if (!cause || typeof cause !== "object" || !("code" in cause)) {
+        return null;
+    }
+    const code = cause.code;
+    return typeof code === "string" ? code : null;
+}

package/dist/workers/http-runner.js

@@ -0,0 +1,55 @@
+import { makeError } from "../errors.js";
+export async function dispatchHttpRunner(task, opts) {
+    const startTime = Date.now();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), task.timeout_ms);
+    let res;
+    try {
+        res = await fetch(opts.url, {
+            method: "POST",
+            headers: opts.headers,
+            body: JSON.stringify(opts.body),
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        const duration_ms = Date.now() - startTime;
+        if (err.name === "AbortError") {
+            return {
+                status: "timeout",
+                output: "",
+                duration_ms,
+                exit_code: null,
+                error: makeError("TIMEOUT", opts.timeoutMessage?.(task.timeout_ms) ??
+                    `${opts.providerName} timed out after ${task.timeout_ms}ms`, true),
+            };
+        }
+        return {
+            status: "error",
+            output: "",
+            duration_ms,
+            exit_code: null,
+            error: makeError("PROVIDER_ERROR", opts.fetchFailureMessage?.(err) ??
+                `${opts.providerName} fetch failed: ${String(err)}`, true),
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    const duration_ms = Date.now() - startTime;
+    if (!res.ok) {
+        const body = await res.text();
+        return {
+            status: "error",
+            output: "",
+            duration_ms,
+            exit_code: res.status,
+            error: makeError("PROVIDER_ERROR", opts.responseErrorMessage?.(res.status, body) ??
+                `${opts.providerName} returned ${res.status}: ${body}`, res.status >= 500),
+        };
+    }
+    const body = (await res.json());
+    const { output, token_usage } = opts.parseResponse(body);
+    task.logStream?.write(output + "\n");
+    return { status: "success", output, duration_ms, exit_code: 0, token_usage };
+}

package/dist/workers/lmstudio.js

@@ -1,5 +1,6 @@
 import { makeError } from "../errors.js";
 import { getLmStudioEndpoint, getLmStudioApiKey } from "../config/providers.js";
+import { dispatchHttpRunner } from "./http-runner.js";
 export function parseLmStudioResponse(body) {
     const choices = body["choices"] ?? [];
     const output = choices[0]?.message?.content ?? "";
@@ -20,9 +21,6 @@ export class LmStudioRunner {
         }
         const endpoint = getLmStudioEndpoint();
         const apiKey = getLmStudioApiKey();
-        const startTime = Date.now();
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), task.timeout_ms);
         const headers = {
             "Content-Type": "application/json",
         };
@@ -33,52 +31,13 @@ export class LmStudioRunner {
             model,
             messages: [{ role: "user", content: task.task }],
         };
-        let res;
-        try {
-            res = await fetch(`${endpoint}/v1/chat/completions`, {
-                method: "POST",
-                headers,
-                body: JSON.stringify(requestBody),
-                signal: controller.signal,
-            });
-        }
-        catch (err) {
-            clearTimeout(timeout);
-            const duration_ms = Date.now() - startTime;
-            if (err.name === "AbortError") {
-                return {
-                    status: "timeout",
-                    output: "",
-                    duration_ms,
-                    exit_code: null,
-                    error: makeError("TIMEOUT", `LM Studio timed out after ${task.timeout_ms}ms`, true),
-                };
-            }
-            return {
-                status: "error",
-                output: "",
-                duration_ms,
-                exit_code: null,
-                error: makeError("PROVIDER_ERROR", `LM Studio fetch failed: ${String(err)}. Is it running at ${endpoint}?`, true),
-            };
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-        const duration_ms = Date.now() - startTime;
-        if (!res.ok) {
-            const body = await res.text();
-            return {
-                status: "error",
-                output: "",
-                duration_ms,
-                exit_code: res.status,
-                error: makeError("PROVIDER_ERROR", `LM Studio returned ${res.status}: ${body}`, res.status >= 500),
-            };
-        }
-        const body = (await res.json());
-        const { output, token_usage } = parseLmStudioResponse(body);
-        task.logStream?.write(output + "\n");
-        return { status: "success", output, duration_ms, exit_code: 0, token_usage };
+        return dispatchHttpRunner(task, {
+            url: `${endpoint}/v1/chat/completions`,
+            headers,
+            body: requestBody,
+            parseResponse: parseLmStudioResponse,
+            providerName: "LM Studio",
+            fetchFailureMessage: (err) => `LM Studio fetch failed: ${String(err)}. Is it running at ${endpoint}?`,
+        });
     }
 }

package/dist/workers/openrouter.js

@@ -1,5 +1,6 @@
 import { makeError } from "../errors.js";
 import { getOpenRouterApiKey } from "../config/providers.js";
+import { dispatchHttpRunner } from "./http-runner.js";
 export function parseOpenRouterResponse(body) {
     const choices = body["choices"] ?? [];
     const output = choices[0]?.message?.content ?? "";
@@ -28,61 +29,18 @@ export class OpenRouterRunner {
                 error: makeError("PROVIDER_NOT_CONFIGURED", "OPENROUTER_API_KEY is not set. Add it to your MCP config env.", false),
             };
         }
-        const startTime = Date.now();
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), task.timeout_ms);
-        let res;
-        try {
-            res = await fetch("https://openrouter.ai/api/v1/chat/completions", {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${apiKey}`,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    model,
-                    messages: [{ role: "user", content: task.task }],
-                }),
-                signal: controller.signal,
-            });
-        }
-        catch (err) {
-            clearTimeout(timeout);
-            const duration_ms = Date.now() - startTime;
-            if (err.name === "AbortError") {
-                return {
-                    status: "timeout",
-                    output: "",
-                    duration_ms,
-                    exit_code: null,
-                    error: makeError("TIMEOUT", `OpenRouter timed out after ${task.timeout_ms}ms`, true),
-                };
-            }
-            return {
-                status: "error",
-                output: "",
-                duration_ms,
-                exit_code: null,
-                error: makeError("PROVIDER_ERROR", `OpenRouter fetch failed: ${String(err)}`, true),
-            };
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-        const duration_ms = Date.now() - startTime;
-        if (!res.ok) {
-            const body = await res.text();
-            return {
-                status: "error",
-                output: "",
-                duration_ms,
-                exit_code: res.status,
-                error: makeError("PROVIDER_ERROR", `OpenRouter returned ${res.status}: ${body}`, res.status >= 500),
-            };
-        }
-        const body = (await res.json());
-        const { output, token_usage } = parseOpenRouterResponse(body);
-        task.logStream?.write(output + "\n");
-        return { status: "success", output, duration_ms, exit_code: 0, token_usage };
+        return dispatchHttpRunner(task, {
+            url: "https://openrouter.ai/api/v1/chat/completions",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: {
+                model,
+                messages: [{ role: "user", content: task.task }],
+            },
+            parseResponse: parseOpenRouterResponse,
+            providerName: "OpenRouter",
+        });
     }
 }

package/dist/workers/registry.js

@@ -1,15 +1,15 @@
 import { CodexRunner } from "./codex.js";
 import { OpenRouterRunner } from "./openrouter.js";
 import { LmStudioRunner } from "./lmstudio.js";
+import { isSupportedProvider } from "../config/providers.js";
 const runners = {
     codex: new CodexRunner(),
     openrouter: new OpenRouterRunner(),
     lmstudio: new LmStudioRunner(),
 };
 export function getRunner(provider) {
-    const runner = runners[provider];
-    if (!runner) {
+    if (!isSupportedProvider(provider)) {
         throw new Error(`PROVIDER_NOT_CONFIGURED: unknown provider "${provider}"`);
     }
-    return runner;
+    return runners[provider];
 }

package/package.json

@@ -1,8 +1,24 @@
 {
   "name": "@sghanavati/relay-mcp",
-  "version": "0.1.4",
-  "description": "MCP server that lets Claude Code delegate coding tasks to Codex",
+  "version": "0.1.6",
+  "description": "MCP server for Claude Code delegation across Codex, OpenRouter, and LM Studio",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ghanavati/relay-mcp.git"
+  },
+  "homepage": "https://github.com/ghanavati/relay-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/ghanavati/relay-mcp/issues"
+  },
+  "keywords": [
+    "mcp",
+    "claude-code",
+    "codex",
+    "openrouter",
+    "lmstudio",
+    "orchestration"
+  ],
   "bin": {
     "relay-mcp": "dist/index.js"
   },
@@ -12,6 +28,7 @@
   "files": [
     "dist/",
     "LICENSE",
+    "README.md",
     "!dist/**/*.test.js"
   ],
   "scripts": {
@@ -25,12 +42,13 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.20.2",
-    "zod": "^3.25.0",
+    "async-mutex": "^0.5.0",
     "execa": "^9.6.0",
-    "async-mutex": "^0.5.0"
+    "zod": "^3.25.0"
   },
   "devDependencies": {
-    "typescript": "^5.0.0",
-    "@types/node": "^22.0.0"
-  }
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  },
+  "license": "MIT"
 }