@reqvire-org/ads 0.0.0-stage → 0.2.9

package/dist/mcp/showcase-host.mjs

@@ -0,0 +1,68 @@
+import { createServer } from "node:http";
+import { readFile } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { createMcpHandler } from "@modelcontextprotocol/server";
+import { startSandboxHost } from "./sandbox-host.mjs";
+
+/** A loopback HTTP MCP transport and static client; neither renders project UI. */
+export async function startShowcaseHost(factory, { port = 0, observe } = {}) {
+  const assets = new Map(await Promise.all([
+    ["/", "index.html", "text/html"], ["/client.js", "client.bundle.js", "text/javascript"], ["/style.css", "style.css", "text/css"],
+  ].map(async ([route, file, type]) => [route, { type, bytes: await readFile(new URL(`../showcase/${file}`, import.meta.url)) }])));
+  const handler = createMcpHandler(factory, { legacy: "reject", maxRequestBodySize: 2 * 1024 * 1024 });
+  const observer = observe?.(handler.notify);
+  const requests = new Set();
+  let sandbox;
+  const web = createServer(async (req, res) => {
+    const origin = `http://127.0.0.1:${web.address().port}`;
+    if (req.headers.host !== new URL(origin).host || req.headers["sec-fetch-site"] === "cross-site" || req.headers.origin && req.headers.origin !== origin) {
+      res.writeHead(403); res.end("Only the local showcase may access this host."); return;
+    }
+    const url = new URL(req.url, origin);
+    if (url.pathname === "/host.json" && req.method === "GET") {
+      res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+      res.end(JSON.stringify({ sandboxUrl: sandbox?.url })); return;
+    }
+    const asset = assets.get(url.pathname);
+    if (req.method === "GET" && (asset || url.pathname === "/favicon.ico")) {
+      res.writeHead(asset ? 200 : 204, { "Content-Type": asset?.type ?? "image/x-icon", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff", "Content-Security-Policy": `default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'; frame-src ${sandbox ? new URL(sandbox.url).origin : "'none'"};connect-src 'self';object-src 'none'` });
+      res.end(asset?.bytes); return;
+    }
+    if (url.pathname !== "/mcp") { res.writeHead(404); res.end("Not found"); return; }
+    const abort = new AbortController();
+    requests.add(abort);
+    res.once("close", () => { requests.delete(abort); abort.abort(); });
+    try {
+      const request = new Request(url, { method: req.method, headers: req.headers, signal: abort.signal,
+        ...(req.method === "POST" ? { body: Readable.toWeb(req), duplex: "half" } : {}) });
+      const response = await handler.fetch(request);
+      res.writeHead(response.status, Object.fromEntries(response.headers));
+      if (response.body) {
+        const stream = Readable.fromWeb(response.body);
+        stream.on("error", () => res.destroy());
+        res.once("close", () => stream.destroy());
+        stream.pipe(res);
+      } else res.end();
+    } catch (error) {
+      if (!res.headersSent) { res.writeHead(500); res.end(error.message); }
+      else res.destroy();
+    }
+  });
+  try {
+    await new Promise((resolve, reject) => { web.once("error", reject); web.listen(port, "127.0.0.1", resolve); });
+    sandbox = await startSandboxHost(`http://127.0.0.1:${web.address().port}`);
+  }
+  catch (error) { web.close(); await observer?.close(); await handler.close(); throw error; }
+  let closing;
+  return { url: `http://127.0.0.1:${web.address().port}/`, close() {
+    return closing ??= (async () => {
+      for (const request of requests) request.abort();
+      await observer?.close();
+      await handler.close();
+      await sandbox?.close();
+      const stopped = new Promise(resolve => web.close(resolve));
+      web.closeAllConnections();
+      await stopped;
+    })();
+  } };
+}

package/dist/mcp/skills.mjs

@@ -0,0 +1,77 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { parse } from "yaml";
+import { ProtocolError, INVALID_PARAMS } from "@modelcontextprotocol/server";
+
+export const SKILLS_EXTENSION = "io.modelcontextprotocol/skills";
+export const SKILLS_ROOT = "skill://ads";
+export const digest = (bytes) => `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+
+export function page(items, cursor, namespace, size = 25) {
+  const revision = digest(Buffer.from(JSON.stringify(items))).slice(7, 23);
+  let offset = 0;
+  if (cursor !== undefined) {
+    const match = new RegExp(`^${namespace}:${revision}:(\\d+)$`).exec(cursor);
+    offset = match ? Number(match[1]) : -1;
+    if (!Number.isSafeInteger(offset) || offset <= 0 || offset >= items.length || offset % size) throw new ProtocolError(INVALID_PARAMS, "Invalid or stale listing cursor; start the listing again.");
+  }
+  return { items: items.slice(offset, offset + size), ...(offset + size < items.length ? { nextCursor: `${namespace}:${revision}:${offset + size}` } : {}) };
+}
+
+/** A packaged, immutable snapshot: the bytes read match the advertised manifest. */
+export function createSkillStore(directory = fileURLToPath(new URL("../skills/", import.meta.url))) {
+  const files = new Map();
+  const directories = new Map([[SKILLS_ROOT, []]]);
+  const skills = [];
+  if (!existsSync(directory)) throw new Error("ADS skill distribution is missing; run npm run build.");
+  function walk(folder, uri, manifest) {
+    const children = [];
+    directories.set(uri, children);
+    for (const entry of readdirSync(folder, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (entry.isSymbolicLink()) throw new Error(`Skills cannot contain symlinks: ${entry.name}`);
+      const name = entry.name === "gitignore.template" ? ".gitignore" : entry.name;
+      const childUri = `${uri}/${encodeURIComponent(name)}`;
+      const file = path.join(folder, entry.name);
+      if (entry.isDirectory()) {
+        children.push({ uri: childUri, name, mimeType: "inode/directory" });
+        walk(file, childUri, manifest);
+      } else if (entry.isFile()) {
+        const bytes = readFileSync(file);
+        const text = !bytes.includes(0) && Buffer.from(bytes.toString("utf8")).equals(bytes);
+        const mimeType = text ? file.endsWith(".json") ? "application/json" : file.endsWith(".md") ? "text/markdown" : "text/plain" : "application/octet-stream";
+        files.set(childUri, { uri: childUri, name, mimeType, bytes, text });
+        children.push({ uri: childUri, name, mimeType });
+        manifest.push({ uri: childUri, digest: digest(bytes), size: bytes.length });
+      }
+    }
+  }
+  for (const entry of readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!entry.isDirectory() || !existsSync(path.join(directory, entry.name, "SKILL.md"))) continue;
+    const folder = path.join(directory, entry.name);
+    const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(readFileSync(path.join(folder, "SKILL.md"), "utf8"));
+    const frontmatter = match && parse(match[1], { maxAliasCount: 25 });
+    if (!frontmatter || frontmatter.name !== entry.name || typeof frontmatter.description !== "string" || !/^[a-z][a-z0-9-]*$/.test(frontmatter.name)) throw new Error(`Invalid skill frontmatter: ${entry.name}`);
+    const uri = `${SKILLS_ROOT}/${entry.name}`;
+    const manifest = [];
+    directories.get(SKILLS_ROOT).push({ uri, name: entry.name, mimeType: "inode/directory" });
+    walk(folder, uri, manifest);
+    skills.push({ uri: `${uri}/SKILL.md`, frontmatter, resources: manifest });
+  }
+  return {
+    skills,
+    files,
+    directories,
+    get(uri) {
+      const skill = skills.find((entry) => entry.uri === uri);
+      if (!skill) throw new Error("Unknown skill URI.");
+      return skill;
+    },
+    read(uri) {
+      const file = files.get(uri);
+      if (!file) throw new Error("Unknown skill file URI.");
+      return { uri, mimeType: file.mimeType, ...(file.text ? { text: file.bytes.toString("utf8") } : { blob: file.bytes.toString("base64") }) };
+    },
+  };
+}