@happyvertical/smrt-app-cli 0.37.2 → 0.37.3

package/dist/bin/smrt-mcp-bridge.js

@@ -1,29 +1,48 @@
 #!/usr/bin/env node
-import { d as runMcpStdioBridge } from "../config-Bgq_EQoJ.js";
+import { l as runMcpStdioBridge } from "../config-DB4AMYT0.js";
+//#region src/bin/smrt-mcp-bridge.ts
+/**
+* `smrt-mcp-bridge` — generic stdio MCP bridge.
+*
+* Usage:
+*
+* ```
+* smrt-mcp-bridge --env-prefix=WILLGRIFFIN \
+*   --name=willgriffin-mcp --version=0.1.0
+* ```
+*
+* All options can also be passed as env vars:
+*
+*  - `SMRT_MCP_ENV_PREFIX` — env-prefix the bridge uses to look up the app's
+*    server URL/token/config file.
+*  - `SMRT_MCP_APP_SLUG` — directory name under `~/.config`.
+*  - `SMRT_MCP_SERVER_NAME` / `SMRT_MCP_SERVER_VERSION` — local server identity.
+*  - `SMRT_MCP_DEFAULT_SERVER_URL` — fallback server URL.
+*
+* Apps that want their own branded bin should call `runMcpStdioBridge`
+* directly from `@happyvertical/smrt-app-mcp/cli` instead of going through
+* this generic entrypoint.
+*/
 function readArg(name) {
-  const prefix = `--${name}=`;
-  const match = process.argv.find((arg) => arg.startsWith(prefix));
-  if (match) return match.slice(prefix.length);
-  const flagIdx = process.argv.indexOf(`--${name}`);
-  if (flagIdx >= 0 && flagIdx + 1 < process.argv.length) {
-    return process.argv[flagIdx + 1];
-  }
-  return void 0;
+	const prefix = `--${name}=`;
+	const match = process.argv.find((arg) => arg.startsWith(prefix));
+	if (match) return match.slice(prefix.length);
+	const flagIdx = process.argv.indexOf(`--${name}`);
+	if (flagIdx >= 0 && flagIdx + 1 < process.argv.length) return process.argv[flagIdx + 1];
 }
-const envPrefix = readArg("env-prefix") ?? process.env.SMRT_MCP_ENV_PREFIX ?? "";
+var envPrefix = readArg("env-prefix") ?? process.env.SMRT_MCP_ENV_PREFIX ?? "";
 if (!envPrefix) {
-  console.error(
-    "smrt-mcp-bridge: --env-prefix=<PREFIX> (or SMRT_MCP_ENV_PREFIX) is required."
-  );
-  process.exit(2);
+	console.error("smrt-mcp-bridge: --env-prefix=<PREFIX> (or SMRT_MCP_ENV_PREFIX) is required.");
+	process.exit(2);
 }
-const appSlug = readArg("app-slug") ?? process.env.SMRT_MCP_APP_SLUG;
-const defaultServerUrl = readArg("default-server-url") ?? process.env.SMRT_MCP_DEFAULT_SERVER_URL;
-const serverName = readArg("name") ?? process.env.SMRT_MCP_SERVER_NAME ?? "smrt-app-mcp";
-const serverVersion = readArg("version") ?? process.env.SMRT_MCP_SERVER_VERSION ?? "0.0.0";
 await runMcpStdioBridge({
-  envPrefix,
-  appSlug,
-  defaultServerUrl,
-  serverInfo: { name: serverName, version: serverVersion }
+	envPrefix,
+	appSlug: readArg("app-slug") ?? process.env.SMRT_MCP_APP_SLUG,
+	defaultServerUrl: readArg("default-server-url") ?? process.env.SMRT_MCP_DEFAULT_SERVER_URL,
+	serverInfo: {
+		name: readArg("name") ?? process.env.SMRT_MCP_SERVER_NAME ?? "smrt-app-mcp",
+		version: readArg("version") ?? process.env.SMRT_MCP_SERVER_VERSION ?? "0.0.0"
+	}
 });
+//#endregion
+export {};

package/dist/bridge-sTKlA6Hz.js

@@ -0,0 +1,2 @@
+import { l as runMcpStdioBridge } from "./config-DB4AMYT0.js";
+export { runMcpStdioBridge };

package/dist/config-DB4AMYT0.js

@@ -0,0 +1,213 @@
+import { randomBytes } from "node:crypto";
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+//#region src/bridge.ts
+/**
+* Stdio MCP bridge — pipes a remote SMRT app's HTTP MCP surface
+* (`/api/mcp/tools` + `/api/mcp/call`) to a local stdio MCP server so that
+* editors and AI clients can connect to it.
+*
+* Apps wire this up by providing their own bin script:
+*
+* ```ts
+* #!/usr/bin/env node
+* import { runMcpStdioBridge } from '@happyvertical/smrt-app-cli';
+* await runMcpStdioBridge({
+*   envPrefix: 'WILLGRIFFIN',
+*   serverInfo: { name: 'willgriffin-mcp', version: '0.1.0' },
+* });
+* ```
+*
+* The package also ships a `smrt-mcp-bridge` bin (see `bin/smrt-mcp-bridge`)
+* that reads `--env-prefix=…` from argv for ad-hoc use without writing a
+* package-specific entry point.
+*
+* @packageDocumentation
+*/
+/**
+* Wire up the stdio server. Use `runMcpStdioBridge` for a one-call entry
+* point in `bin/` scripts; this lower-level form is exposed for tests.
+*/
+function createMcpStdioBridge(options) {
+	const toolsPath = options.toolsPath ?? "/api/mcp/tools";
+	const callPath = options.callPath ?? "/api/mcp/call";
+	const server = new Server(options.serverInfo, { capabilities: { tools: {} } });
+	server.setRequestHandler(ListToolsRequestSchema, async (_request) => {
+		return requestJson(options, toolsPath, { method: "GET" }, { fetch: options.fetch });
+	});
+	server.setRequestHandler(CallToolRequestSchema, async (request) => {
+		const { name, arguments: args = {} } = request.params;
+		try {
+			return await requestJson(options, callPath, {
+				body: JSON.stringify({
+					arguments: args,
+					name
+				}),
+				method: "POST"
+			}, { fetch: options.fetch });
+		} catch (error) {
+			return {
+				content: [{
+					text: error instanceof Error ? error.message : "MCP tool call failed.",
+					type: "text"
+				}],
+				isError: true
+			};
+		}
+	});
+	return {
+		server,
+		connect: () => server.connect(new StdioServerTransport())
+	};
+}
+/**
+* One-call entry point — instantiate the bridge and connect stdio. Returns
+* a `Promise<void>` that resolves once the transport disconnects.
+*/
+async function runMcpStdioBridge(options) {
+	const { connect } = createMcpStdioBridge(options);
+	await connect();
+}
+//#endregion
+//#region src/config.ts
+/**
+* Shared CLI helpers for SMRT apps: a small config file format, env var
+* resolution with a configurable prefix, and a minimal JSON HTTP client
+* that knows how to bear the stored CLI token.
+*
+* The same helpers back the stdio bridge (`smrt-mcp-bridge`) and any
+* app-specific `data`-style commands that talk to the app's HTTP API.
+*
+* @packageDocumentation
+*/
+var DEFAULT_LOCAL_SERVER = "http://localhost:5173";
+function configFilePath(context) {
+	const override = process.env[`${context.envPrefix}_CLI_CONFIG`];
+	if (override) return override;
+	const slug = context.appSlug ?? context.envPrefix.toLowerCase();
+	return join(homedir(), ".config", slug, "config.json");
+}
+/** Read the CLI config file. Missing file → empty config. */
+async function loadCliConfig(context) {
+	try {
+		const raw = await readFile(configFilePath(context), "utf8");
+		if (!raw.trim()) return {};
+		return JSON.parse(raw);
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return {};
+		throw error;
+	}
+}
+/**
+* Write the CLI config to disk with 0600 permissions (the token is a bearer
+* credential — anyone who can read the file can impersonate the user).
+*/
+async function saveCliConfig(context, config) {
+	const path = configFilePath(context);
+	const dir = dirname(path);
+	await mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	await chmod(dir, 448).catch(() => void 0);
+	const tmp = `${path}.${randomBytes(6).toString("hex")}.tmp`;
+	try {
+		await writeFile(tmp, `${JSON.stringify(config, null, 2)}\n`, { mode: 384 });
+		await chmod(tmp, 384);
+		await rename(tmp, path);
+	} catch (err) {
+		await unlink(tmp).catch(() => void 0);
+		throw err;
+	}
+}
+/** Resolve the server URL: env var → config file → `defaultServerUrl`. */
+async function getServerUrl(context, config) {
+	const resolved = config ?? await loadCliConfig(context);
+	return (process.env[`${context.envPrefix}_SERVER_URL`] ?? resolved.serverUrl ?? context.defaultServerUrl ?? DEFAULT_LOCAL_SERVER).replace(/\/+$/u, "");
+}
+/** Resolve the stored bearer token (env var wins over config). */
+async function getStoredToken(context, config) {
+	const resolved = config ?? await loadCliConfig(context);
+	return process.env[`${context.envPrefix}_TOKEN`] ?? resolved.token;
+}
+/** Remove the token from the config file (e.g. on logout). */
+async function clearStoredToken(context) {
+	const config = await loadCliConfig(context);
+	delete config.token;
+	await saveCliConfig(context, config);
+}
+/** Persist a login: writes both serverUrl and token to the config file. */
+async function saveAuth(context, serverUrl, token) {
+	await saveCliConfig(context, {
+		...await loadCliConfig(context),
+		serverUrl: serverUrl.replace(/\/+$/u, ""),
+		token
+	});
+}
+var DEFAULT_MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
+/**
+* JSON request helper that injects the stored bearer token. Returns the
+* parsed JSON body on success; throws an `Error` with the server's `error`
+* field (or `HTTP <status>`) on failure.
+*/
+async function requestJson(context, path, init = {}, options = {}) {
+	const config = options.loadedConfig ?? await loadCliConfig(context);
+	const serverUrl = (options.serverUrl ?? await getServerUrl(context, config)).replace(/\/+$/u, "");
+	const token = await getStoredToken(context, config);
+	const headers = new Headers(init.headers);
+	if (options.requireAuth && options.auth !== false && !token) throw new Error(`Not authenticated. Run \`${context.envPrefix.toLowerCase()} auth login\` first.`);
+	if (!headers.has("content-type") && init.body) headers.set("content-type", "application/json");
+	if (options.auth !== false && token) headers.set("authorization", `Bearer ${token}`);
+	const response = await (options.fetch ?? fetch)(`${serverUrl}${path}`, {
+		...init,
+		headers
+	});
+	const contentType = response.headers.get("content-type") ?? "";
+	const text = await readBodyWithCap(response, options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES);
+	const parsed = contentType.includes("application/json") && text ? JSON.parse(text) : text;
+	if (!response.ok) {
+		const message = parsed && typeof parsed === "object" && "error" in parsed ? String(parsed.error) : `HTTP ${response.status}: ${response.statusText}`;
+		throw Object.assign(new Error(message), { status: response.status });
+	}
+	return parsed;
+}
+/**
+* Read the response body into a UTF-8 string, capping at `maxBytes`. On
+* overflow, throw with a clear message — better than OOM-ing the CLI
+* when a server returns a multi-GB body. Streams chunk-by-chunk so the
+* check fires before the whole body is buffered. (#1311 review A4.)
+*/
+async function readBodyWithCap(response, maxBytes) {
+	if (!response.body) return "";
+	const cl = Number(response.headers.get("content-length") ?? "");
+	if (Number.isFinite(cl) && cl > maxBytes) {
+		try {
+			await response.body.cancel();
+		} catch {}
+		throw new Error(`Response too large: ${cl} bytes exceeds ${maxBytes}-byte cap`);
+	}
+	const reader = response.body.getReader();
+	const chunks = [];
+	let size = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (!value) continue;
+			size += value.byteLength;
+			if (size > maxBytes) throw new Error(`Response too large: exceeded ${maxBytes}-byte cap mid-stream`);
+			chunks.push(value);
+		}
+	} finally {
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+	return new TextDecoder().decode(Buffer.concat(chunks.map((c) => Buffer.from(c))));
+}
+//#endregion
+export { requestJson as a, createMcpStdioBridge as c, loadCliConfig as i, runMcpStdioBridge as l, getServerUrl as n, saveAuth as o, getStoredToken as r, saveCliConfig as s, clearStoredToken as t };