@humain/terminal 0.0.2 → 0.0.3-beta.0

package/dist/humain/mcp-adapter/vendor/mcp-probe.ts

@@ -0,0 +1,187 @@
+const PROBE_TIMEOUT_MS = 5_000;
+const MODERN_PROTOCOL_VERSION = "2026-07-28";
+const LEGACY_PROTOCOL_VERSION = "2025-06-18";
+const JSON_ACCEPT = "application/json, text/event-stream";
+const SSE_ACCEPT = "text/event-stream";
+const MODERN_FALLBACK_STATUSES = new Set([400, 401, 404, 405, 406, 415]);
+const POST_ENDPOINT_MISMATCH_STATUSES = new Set([404, 405, 406, 415]);
+
+export interface McpProbeResult {
+  isMcp: boolean;
+  classification: string;
+}
+
+const DISCOVER_REQUEST = {
+  jsonrpc: "2.0",
+  id: 1,
+  method: "server/discover",
+  params: {},
+};
+
+const INITIALIZE_REQUEST = {
+  jsonrpc: "2.0",
+  id: 1,
+  method: "initialize",
+  params: {
+    protocolVersion: LEGACY_PROTOCOL_VERSION,
+    capabilities: {},
+    clientInfo: { name: "pi-mcp-probe", version: "2.1.2" },
+  },
+};
+
+type ProbeStrategy =
+  | { kind: "modern"; request: RequestInit; allowJson: true }
+  | { kind: "legacy-post"; request: RequestInit; allowJson: true }
+  | { kind: "legacy-sse"; request: RequestInit; allowJson: false };
+
+const MODERN_STRATEGY: ProbeStrategy = {
+  kind: "modern",
+  request: {
+    method: "POST",
+    headers: {
+      Accept: JSON_ACCEPT,
+      "Content-Type": "application/json",
+      "MCP-Protocol-Version": MODERN_PROTOCOL_VERSION,
+      "Mcp-Method": "server/discover",
+    },
+    body: JSON.stringify(DISCOVER_REQUEST),
+  },
+  allowJson: true,
+};
+
+const LEGACY_POST_STRATEGY: ProbeStrategy = {
+  kind: "legacy-post",
+  request: {
+    method: "POST",
+    headers: {
+      Accept: JSON_ACCEPT,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(INITIALIZE_REQUEST),
+  },
+  allowJson: true,
+};
+
+const LEGACY_SSE_STRATEGY: ProbeStrategy = {
+  kind: "legacy-sse",
+  request: { headers: { Accept: SSE_ACCEPT } },
+  allowJson: false,
+};
+
+type JsonRpcEnvelopeInfo =
+  | { kind: "result"; protocolVersion: unknown }
+  | { kind: "error" };
+
+type ProbeOutcome =
+  | { kind: "mcp"; result: McpProbeResult }
+  | { kind: "unsupported-modern" }
+  | { kind: "unrecognized" };
+
+interface ProbeResult {
+  response: Response;
+  outcome: ProbeOutcome;
+}
+
+function jsonRpcEnvelopeInfo(value: unknown): JsonRpcEnvelopeInfo | null {
+  if (typeof value !== "object" || value === null || (value as { jsonrpc?: unknown }).jsonrpc !== "2.0") {
+    return null;
+  }
+  if ("result" in value) {
+    const result = (value as { result?: unknown }).result;
+    return {
+      kind: "result",
+      protocolVersion: typeof result === "object" && result !== null
+        ? (result as { protocolVersion?: unknown }).protocolVersion
+        : undefined,
+    };
+  }
+  if ("error" in value) return { kind: "error" };
+  return null;
+}
+
+function isBearerChallenge(response: Response): boolean {
+  return /(?:^|,)\s*Bearer\b/i.test(response.headers.get("www-authenticate") ?? "");
+}
+
+function responseKind(response: Response): string {
+  const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+  if (contentType === "text/html") return "HTML";
+  if (contentType) return contentType;
+  return "an untyped response";
+}
+
+async function getJsonRpcEnvelopeInfo(response: Response): Promise<JsonRpcEnvelopeInfo | null> {
+  try {
+    return jsonRpcEnvelopeInfo(JSON.parse(await response.text()));
+  } catch {
+    return null;
+  }
+}
+
+async function classifyResponse(response: Response, strategy: ProbeStrategy): Promise<ProbeOutcome> {
+  const isSse = response.headers.get("content-type")?.toLowerCase().startsWith("text/event-stream");
+  if (response.ok && isSse) {
+    return { kind: "mcp", result: { isMcp: true, classification: "endpoint responded with an MCP event stream" } };
+  }
+
+  const envelope = (strategy.allowJson || response.status === 401) ? await getJsonRpcEnvelopeInfo(response) : null;
+  if (response.ok && strategy.allowJson && envelope) {
+    if (strategy.kind === "modern" && (envelope.kind === "error" || envelope.protocolVersion !== MODERN_PROTOCOL_VERSION)) {
+      return { kind: "unsupported-modern" };
+    }
+    return {
+      kind: "mcp",
+      result: {
+        isMcp: true,
+        classification: strategy.kind === "modern"
+          ? `endpoint supports stateless MCP ${MODERN_PROTOCOL_VERSION} server/discover`
+          : "endpoint responded with a JSON-RPC 2.0 envelope",
+      },
+    };
+  }
+  if (response.status === 401 && isBearerChallenge(response) && envelope) {
+    return {
+      kind: "mcp",
+      result: {
+        isMcp: true,
+        classification: strategy.kind === "modern"
+          ? `endpoint requires Bearer authentication during MCP ${MODERN_PROTOCOL_VERSION} server/discover probing`
+          : "endpoint requires Bearer authentication and responded with a JSON-RPC 2.0 error",
+      },
+    };
+  }
+
+  return { kind: "unrecognized" };
+}
+
+async function probe(url: string | URL, strategy: ProbeStrategy): Promise<ProbeResult> {
+  const response = await fetch(url, {
+    ...strategy.request,
+    signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+  });
+  return { response, outcome: await classifyResponse(response, strategy) };
+}
+
+function notMcp(response: Response): McpProbeResult {
+  return {
+    isMcp: false,
+    classification: `endpoint returned ${responseKind(response)} (${response.status}) — this URL does not appear to speak MCP`,
+  };
+}
+
+/** Makes one unauthenticated metadata-only request to identify an HTTP endpoint's protocol shape. */
+export async function probeMcpEndpoint(url: string | URL): Promise<McpProbeResult> {
+  const { response: modernResponse, outcome: modernOutcome } = await probe(url, MODERN_STRATEGY);
+  if (modernOutcome.kind === "mcp") return modernOutcome.result;
+
+  if (modernOutcome.kind !== "unsupported-modern" && !MODERN_FALLBACK_STATUSES.has(modernResponse.status)) {
+    return notMcp(modernResponse);
+  }
+
+  const { response: postResponse, outcome: postOutcome } = await probe(url, LEGACY_POST_STRATEGY);
+  if (postOutcome.kind === "mcp") return postOutcome.result;
+  if (!POST_ENDPOINT_MISMATCH_STATUSES.has(postResponse.status)) return notMcp(postResponse);
+
+  const { response: getResponse, outcome: getOutcome } = await probe(url, LEGACY_SSE_STRATEGY);
+  return getOutcome.kind === "mcp" ? getOutcome.result : notMcp(getResponse);
+}

package/dist/humain/mcp-adapter/vendor/mcp-script-worker.mjs

@@ -0,0 +1,130 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { formatWithOptions } from "node:util";
+import vm from "node:vm";
+
+const TOOLS_ENUMERATION_ERROR = "tools is not enumerable — use tools.search({ query })";
+const RESERVED_TOOL_PROPS = new Set(["then", "catch", "finally", "toJSON", "toString", "valueOf"]);
+
+// Keep this formatting logic in sync with mcp-code.ts; the standalone worker cannot import the TypeScript host module.
+function needsInspectableFormatting(value, stack = new WeakSet()) {
+  if (value === undefined || typeof value === "bigint" || typeof value === "function" || typeof value === "symbol") return true;
+  if (typeof value !== "object" || value === null) return false;
+  if (stack.has(value)) return true;
+  if (value instanceof Map || value instanceof Set || value instanceof WeakMap || value instanceof WeakSet) return true;
+  stack.add(value);
+  try {
+    return Object.values(value).some((entry) => needsInspectableFormatting(entry, stack));
+  } finally {
+    stack.delete(value);
+  }
+}
+
+function formatValue(value) {
+  if (typeof value === "string") return value;
+  try {
+    if (!needsInspectableFormatting(value)) {
+      const json = JSON.stringify(value, null, 2);
+      if (json !== undefined) return json;
+    }
+    return formatWithOptions({ colors: false, depth: 6 }, value);
+  } catch {
+    return "[unserializable value]";
+  }
+}
+
+function toContentBlock(value) {
+  if (typeof value === "object" && value !== null) {
+    if (value.type === "text" && typeof value.text === "string") {
+      return { type: "text", text: value.text };
+    }
+    if (value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string") {
+      return { type: "image", data: value.data, mimeType: value.mimeType };
+    }
+  }
+  return { type: "text", text: formatValue(value) };
+}
+
+let nextRequestId = 0;
+const pending = new Map();
+
+parentPort.on("message", (message) => {
+  if (message?.type !== "result" || typeof message.id !== "number") return;
+  const resolve = pending.get(message.id);
+  if (!resolve) return;
+  pending.delete(message.id);
+  resolve(message.envelope);
+});
+
+function request(type, payload) {
+  return new Promise((resolve) => {
+    const id = ++nextRequestId;
+    pending.set(id, resolve);
+    parentPort.postMessage({ type, id, ...payload });
+  });
+}
+
+const tools = new Proxy(Object.create(null), {
+  get(_target, property) {
+    if (property === "search") {
+      return async (input) => request("search", { input });
+    }
+    if (property === "call") {
+      return async (path, args) => {
+        // Invalid paths never reach dispatch and therefore never appear in the call trace.
+        if (typeof path !== "string" || path.trim() === "") {
+          return {
+            ok: false,
+            error: {
+              code: "invalid_tool_path",
+              message: "tools.call(path, args) requires a non-empty tool path.",
+            },
+          };
+        }
+        return request("call", { path, args });
+      };
+    }
+    if (property === "describe") {
+      return async (input) => request("describe", { input });
+    }
+    if (typeof property !== "string" || RESERVED_TOOL_PROPS.has(property)) return undefined;
+    return (args) => request("call", { path: property, args });
+  },
+  ownKeys() {
+    throw new Error(TOOLS_ENUMERATION_ERROR);
+  },
+});
+
+const emit = (value) => {
+  parentPort.postMessage({ type: "emit", block: toContentBlock(value) });
+};
+
+const capturedConsole = Object.freeze({
+  log: (...args) => emit(`[console.log] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+  info: (...args) => emit(`[console.info] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+  warn: (...args) => emit(`[console.warn] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+  error: (...args) => emit(`[console.error] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+  debug: (...args) => emit(`[console.debug] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+});
+
+void (async () => {
+  try {
+    const context = vm.createContext(Object.assign(Object.create(null), {
+      tools,
+      emit,
+      console: capturedConsole,
+    }), {
+      codeGeneration: { strings: false, wasm: false },
+      name: "mcpScript",
+    });
+    const script = new vm.Script(`(async () => {\n${workerData.code}\n})()`, { filename: "mcpScript.js" });
+    const returnValue = await Promise.resolve(script.runInContext(context));
+    parentPort.postMessage(returnValue === undefined
+      ? { type: "done" }
+      : { type: "done", returnBlock: toContentBlock(returnValue) });
+  } catch (error) {
+    parentPort.postMessage({
+      type: "error",
+      message: error instanceof Error ? error.message : String(error),
+    });
+  }
+})();