@pipeworx/mcp-emoji 0.1.1 → 0.2.0

package/README.md

@@ -2,7 +2,7 @@
 
 Emoji MCP.
 
-Part of [Pipeworx](https://pipeworx.io) — an MCP gateway connecting AI agents to 1679+ live data sources.
+Part of [Pipeworx](https://pipeworx.io) — an MCP gateway connecting AI agents to 1856+ live data sources. This is an independent, unofficial integration — not affiliated with, endorsed by, or published by the upstream provider.
 
 ## Tools
 
@@ -55,7 +55,7 @@ directly, instead of just this one's:
 }
 ```
 
-Both URLs reach the same gateway and the same 1679+ data sources. The
+Both URLs reach the same gateway and the same 1856+ data sources. The
 only difference is which pack's tools are listed **directly**; `ask_pipeworx`
 reaches all of them from either one.
 
@@ -69,10 +69,12 @@ curl -X POST https://gateway.pipeworx.io/v1/tools/emoji_lookup \
 
 No account needed for the first calls. Inspect any tool: `GET https://gateway.pipeworx.io/v1/tools/emoji_lookup`. Find one: `POST https://gateway.pipeworx.io/v1/tools/search_packs` with `{"query":"..."}`.
 
-## Standalone (no gateway account)
+## Run it from npm
 
-This package also runs as a local stdio MCP server — no Pipeworx account, no
-gateway round-trip:
+`@pipeworx/mcp-emoji` is a local stdio bridge to the Pipeworx gateway: your MCP client
+starts it with `npx`, and it forwards every call to the same
+`https://gateway.pipeworx.io/emoji/mcp` endpoint shown above. It needs network access;
+there is no offline mode.
 
 ```json
 {
@@ -85,15 +87,18 @@ gateway round-trip:
 }
 ```
 
-Or run it directly to confirm it starts:
+Without a key it calls anonymously, capped at 50 calls a day. A free account
+raises that to 200 a day: get a key at https://pipeworx.io/signup and add
+`"env": { "PIPEWORX_API_KEY": "<your key>" }` to the server entry.
+The key is sent as a Bearer token, the same way a hosted connection sends it,
+so calls are metered and billed exactly as they are there.
 
-```bash
-npx -y @pipeworx/mcp-emoji
-```
+It lists **only** this pack's tools by default. Set `PIPEWORX_META_TOOLS=1` to
+also list `ask_pipeworx` and the other gateway-wide tools.
 
-It speaks MCP over stdin/stdout and answers `initialize`/`tools/list`/`tools/call`
-for **only** this pack's tools — none of the shared meta-tools the gateway
-connection above adds. Same source, same tools, no ask_pipeworx routing.
+Behind an HTTPS proxy: Node's built-in `fetch` does not read `HTTPS_PROXY` by
+default. Newer Node releases honour it when `NODE_USE_ENV_PROXY=1` is set; check
+your Node version's documentation.
 
 ## Using with ask_pipeworx
 

package/bin/cli.js

@@ -1,17 +1,61 @@
 #!/usr/bin/env node
+// Entry point for `npx @pipeworx/mcp-<slug>` in gateway mode (bin/cli.js).
 //
-// Entry point for `npx @pipeworx/mcp-<slug>`.
+// A stdio MCP server that relays every message to the Pipeworx gateway's
+// /<slug>/mcp endpoint -- fleet #3759, docs/standalone-via-gateway-plan.md.
+// It carries no pack code and has no local mode. The relay itself lives in
+// ../lib/index.js (copied from scripts/templates/standalone-gateway-lib.js);
+// this file only owns stdin/stdout.
 //
-// Packs ship as raw TypeScript (no build step — see publish-pack.sh for why:
-// tsx sidesteps every extensionless-import / bare-JSON-import edge case a
-// per-pack tsc build would have to solve one pack at a time). This file
-// registers tsx's ESM loader programmatically, then hands off to src/server.ts,
-// which wraps the pack's {tools, callTool} export in a stdio MCP server.
+// Copied VERBATIM into every gateway-mode package by scripts/publish-pack.sh.
+// Edit scripts/templates/standalone-gateway-cli.js in the monorepo, never a
+// per-pack copy. Zero dependencies, Node 18+.
 //
-// Copied verbatim into every published pack repo by scripts/publish-pack.sh —
-// edit this file, not a per-pack copy.
-import { register } from 'tsx/esm/api';
+// stdout carries newline-delimited JSON-RPC and nothing else; every diagnostic
+// goes to stderr, because a single stray line on stdout breaks the host's
+// parser.
+import { createInterface } from 'node:readline';
+import { relay, bridgeConfig } from '../lib/index.js';
 
-register();
+const cfg = bridgeConfig();
+const warn = (line) => process.stderr.write(`${line}\n`);
+const write = (msg) => { if (msg) process.stdout.write(`${JSON.stringify(msg)}\n`); };
 
-await import('../src/server.ts');
+const pending = new Set();
+function track(p) {
+  pending.add(p);
+  p.finally(() => pending.delete(p));
+}
+
+async function handleLine(line) {
+  const text = line.trim();
+  if (!text) return;
+  let message;
+  try {
+    message = JSON.parse(text);
+  } catch {
+    write({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } });
+    return;
+  }
+  // A JSON-RPC batch: relay each member, answer with the non-notification replies.
+  if (Array.isArray(message)) {
+    const replies = (await Promise.all(message.map((m) => relay(m, { cfg, warn })))).filter(Boolean);
+    if (replies.length) write(replies);
+    return;
+  }
+  write(await relay(message, { cfg, warn }));
+}
+
+// Requests are handled concurrently and answered as they finish: JSON-RPC ids
+// let the host match them, and a slow tool call must not hold up a ping.
+const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
+rl.on('line', (line) => {
+  track(handleLine(line).catch((err) => warn(`pipeworx-standalone: ${err && err.stack ? err.stack : err}`)));
+});
+rl.on('close', async () => {
+  // stdin closed: finish what is in flight, then exit.
+  while (pending.size) await Promise.allSettled([...pending]);
+  // Exit only once stdout has flushed: on a pipe that is not synchronous
+  // everywhere, and a bare exit can drop the last reply.
+  process.stdout.write('', () => process.exit(0));
+});

package/lib/index.js

@@ -0,0 +1,333 @@
+// @pipeworx/mcp-<slug> -- library half of the gateway bridge (lib/index.js).
+//
+// Copied VERBATIM into every gateway-mode pack package by scripts/publish-pack.sh
+// (fleet #3759, docs/standalone-via-gateway-plan.md section 1). There is no
+// per-pack templating: the slug and version are read from this package's own
+// package.json (`pipeworx.slug`, `version`) at load time, so the same bytes
+// ship in every package and the source hash can cover them once. Edit this
+// file in the monorepo (scripts/templates/standalone-gateway-lib.js), never a
+// per-pack copy.
+//
+// What it is: a relay. Every JSON-RPC message goes to
+// ${PIPEWORX_GATEWAY_URL:-https://gateway.pipeworx.io}/<slug>/mcp, the same
+// endpoint a hosted MCP client uses, so tiers, rate limits and credits apply
+// exactly as they do there. There is no local mode: the pack's code is not in
+// this package.
+//
+// Zero dependencies, plain ESM, Node 18+ (global fetch). Nothing here writes
+// to stdout -- bin/cli.js owns stdout and it carries JSON-RPC only.
+//
+// Environment:
+//   PIPEWORX_API_KEY      sent as `Authorization: Bearer <key>`. Never as
+//                         X-API-Key: the gateway reads a pwx_ key sent that way
+//                         as an unvalidated BYO string with no account.
+//   PIPEWORX_GATEWAY_URL  gateway base URL (no path), default the public gateway.
+//   PIPEWORX_META_TOOLS=1 list the gateway-wide tools (ask_pipeworx, ...) too.
+//   PIPEWORX_TIMEOUT_MS   per-request timeout, default 120000.
+
+import { readFileSync } from 'node:fs';
+
+const readJson = (rel) => JSON.parse(readFileSync(new URL(rel, import.meta.url), 'utf8'));
+
+const PKG = readJson('../package.json');
+export const SLUG = PKG.pipeworx && PKG.pipeworx.slug;
+if (typeof SLUG !== 'string' || !/^[a-z0-9][a-z0-9_-]*$/.test(SLUG)) {
+  throw new Error(`${PKG.name}: package.json carries no valid pipeworx.slug -- this package was built wrong`);
+}
+/**
+ * The pack's slug on the GATEWAY: the /<slug>/mcp route and the `_meta.pack`
+ * every listed tool carries. Usually the same as `slug` (the npm/directory
+ * name), but 14 packs differ -- `hex-pm` is `hex_pm` on the gateway -- and
+ * filtering tools/list on the npm slug would match none of their tools
+ * (fleet #3761). publish-pack.sh stamps it from the gateway manifest.
+ */
+export const GATEWAY_SLUG = (PKG.pipeworx && PKG.pipeworx.gatewaySlug) || SLUG;
+if (typeof GATEWAY_SLUG !== 'string' || !/^[a-z0-9][a-z0-9_-]*$/.test(GATEWAY_SLUG)) {
+  throw new Error(`${PKG.name}: package.json carries an invalid pipeworx.gatewaySlug -- this package was built wrong`);
+}
+export const PACKAGE_NAME = PKG.name;
+export const VERSION = PKG.version;
+
+/** The pack's own tool definitions at publish time (the offline tools/list answer). */
+export const tools = readJson('../tools.json');
+
+const DEFAULT_GATEWAY = 'https://gateway.pipeworx.io';
+const DEFAULT_TIMEOUT_MS = 120_000;
+const SIGNUP_URL = 'https://pipeworx.io/signup';
+const VIA = '(via pipeworx-standalone)';
+
+/** Resolve the bridge's settings. Exported for the tests and for callTool. */
+export function bridgeConfig(env = process.env, overrides = {}) {
+  const base = String(overrides.gatewayUrl || env.PIPEWORX_GATEWAY_URL || DEFAULT_GATEWAY).trim().replace(/\/+$/, '');
+  const apiKey = String(overrides.apiKey ?? env.PIPEWORX_API_KEY ?? '').trim();
+  const t = Number(overrides.timeoutMs ?? env.PIPEWORX_TIMEOUT_MS);
+  return {
+    endpoint: `${base}/${GATEWAY_SLUG}/mcp`,
+    apiKey,
+    timeoutMs: Number.isFinite(t) && t > 0 ? t : DEFAULT_TIMEOUT_MS,
+    metaTools: (overrides.metaTools ?? env.PIPEWORX_META_TOOLS) === '1' || overrides.metaTools === true,
+  };
+}
+
+function requestHeaders(cfg) {
+  const h = {
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+    // Stable per package version: the gateway remembers a client's name by
+    // identifier + User-Agent (workers/gateway/src/client-identity.ts).
+    'User-Agent': `pipeworx-standalone/${VERSION} (${PACKAGE_NAME})`,
+    // Analytics label only (blob11 = 'standalone'). It never changes tier,
+    // limits or price -- anyone can send it.
+    'X-Pipeworx-Surface': 'standalone',
+  };
+  if (cfg.apiKey) h.Authorization = `Bearer ${cfg.apiKey}`;
+  return h;
+}
+
+/** Parse a gateway body: JSON, or the last JSON `data:` frame of an SSE stream. */
+function parseBody(text, contentType) {
+  if (/text\/event-stream/i.test(contentType || '')) {
+    let last = null;
+    for (const line of text.split(/\r?\n/)) {
+      if (!line.startsWith('data:')) continue;
+      try { last = JSON.parse(line.slice(5).trim()); } catch { /* keep-alive or partial frame */ }
+    }
+    return last;
+  }
+  try { return JSON.parse(text); } catch { return null; }
+}
+
+/**
+ * POST one JSON-RPC message. Never throws: the outcome is one of
+ *   { kind: 'http', status, headers, body, text }   the gateway answered
+ *   { kind: 'network', detail }                      DNS, TLS, refused, reset
+ *   { kind: 'timeout' }                              no answer in cfg.timeoutMs
+ */
+export async function postToGateway(message, cfg) {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), cfg.timeoutMs);
+  try {
+    const res = await fetch(cfg.endpoint, {
+      method: 'POST',
+      headers: requestHeaders(cfg),
+      body: JSON.stringify(message),
+      signal: ac.signal,
+    });
+    const text = await res.text();
+    return { kind: 'http', status: res.status, headers: res.headers, body: parseBody(text, res.headers.get('content-type')), text };
+  } catch (err) {
+    if (ac.signal.aborted || (err && (err.name === 'AbortError' || err.name === 'TimeoutError'))) return { kind: 'timeout' };
+    const cause = err && err.cause;
+    const detail = (cause && (cause.code || cause.message)) || (err && err.message) || String(err);
+    return { kind: 'network', detail };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ── The key-not-accepted warning (one per process) ──────────────────
+
+let warnedKeyIgnored = false;
+const KEY_IGNORED = 'PIPEWORX_API_KEY was not accepted, calling anonymously.';
+
+/** True when a key was sent but the gateway still served the call as anonymous. */
+function keyIgnored(out, cfg) {
+  return !!cfg.apiKey && out.kind === 'http' && (out.headers.get('x-ratelimit-tier') || '').toLowerCase() === 'anonymous';
+}
+
+function noteTier(out, cfg, warn) {
+  if (!keyIgnored(out, cfg) || warnedKeyIgnored) return;
+  warnedKeyIgnored = true;
+  warn(`${PACKAGE_NAME}: ${KEY_IGNORED} Check the key at ${SIGNUP_URL}.`);
+}
+
+/** Test hook: forget that the warning was printed. */
+export function _resetWarnings() { warnedKeyIgnored = false; }
+
+// ── Results the host shows to the model ─────────────────────────────
+
+function errorResult(text, detail) {
+  const result = { content: [{ type: 'text', text }], isError: true };
+  if (detail) result._meta = { pipeworx_standalone: detail };
+  return result;
+}
+
+const rpcResult = (id, result) => ({ jsonrpc: '2.0', id, result });
+const rpcError = (id, code, message) => ({ jsonrpc: '2.0', id, error: { code, message } });
+
+function firstLine(text) {
+  const line = String(text || '').split(/\r?\n/).map((l) => l.trim()).find(Boolean) || '(empty body)';
+  return line.length > 200 ? `${line.slice(0, 200)}...` : line;
+}
+
+function unreachableText(cfg, out) {
+  if (out.kind === 'timeout') {
+    return `The Pipeworx gateway at ${cfg.endpoint} did not answer within ${Math.round(cfg.timeoutMs / 1000)}s, so this call timed out. `
+      + `${PACKAGE_NAME} forwards every call to the Pipeworx gateway and has no local mode. Try again; a call that keeps timing out is worth reporting.`;
+  }
+  return `Could not reach the Pipeworx gateway at ${cfg.endpoint} (${out.detail}). `
+    + `${PACKAGE_NAME} forwards every call to the Pipeworx gateway and has no local mode, so it needs network access.`;
+}
+
+function isAuthRequired(body) {
+  return !!body && (body.error_code === 'authentication_required'
+    || (body.error && body.error.data && body.error.data.reason === 'authentication_required'));
+}
+
+/** Map a tools/call outcome to the JSON-RPC response the host gets. */
+function toolsCallResponse(id, out, cfg) {
+  if (out.kind !== 'http') return rpcResult(id, errorResult(unreachableText(cfg, out), { reason: out.kind }));
+  const { status, body } = out;
+
+  // Anonymous daily cap: the gateway answers 401 with a JSON-RPC error whose
+  // message is the offer. Hosts often swallow protocol errors, so hand it over
+  // as a tool result the model actually reads.
+  if (status === 401 && isAuthRequired(body)) {
+    const data = (body.error && body.error.data) || {};
+    const parts = [body.error && body.error.message ? body.error.message : 'The anonymous daily allowance is used up.'];
+    if (data.resets_at) parts.push(`The anonymous allowance resets at ${data.resets_at}.`);
+    parts.push(cfg.apiKey
+      ? `${KEY_IGNORED} Check the key, or get a free one at ${SIGNUP_URL}.`
+      : `To keep going now, set PIPEWORX_API_KEY in this MCP server's environment; a free key is at ${SIGNUP_URL}.`);
+    return rpcResult(id, errorResult(parts.join('\n\n'), { status, reason: 'authentication_required', resets_at: data.resets_at ?? null }));
+  }
+
+  // A keyed tier over its cap: today the gateway answers 429 with a RESULT
+  // that has no isError, which reads as a success (fleet #3760). Mark it.
+  if (status === 429 && body && body.result && typeof body.result === 'object') {
+    const result = { ...body.result, isError: true };
+    if (cfg.apiKey && keyIgnored(out, cfg)) {
+      result.content = [...(Array.isArray(result.content) ? result.content : []), { type: 'text', text: KEY_IGNORED }];
+    }
+    return rpcResult(id, result);
+  }
+  if ((status === 401 || status === 429) && body && body.error) {
+    const extra = keyIgnored(out, cfg) ? ` ${KEY_IGNORED}` : '';
+    return rpcResult(id, errorResult(`${body.error.message || `HTTP ${status}`}${extra}`, { status }));
+  }
+
+  // A real JSON-RPC answer (result or protocol error): relay it verbatim,
+  // structuredContent and _meta (cost, tier, provenance) included.
+  if (body && body.jsonrpc === '2.0' && (body.result !== undefined || body.error !== undefined) && status < 500) {
+    return { ...body, id };
+  }
+
+  // 5xx, an HTML edge page, or anything else that is not JSON-RPC.
+  return rpcResult(id, errorResult(`The Pipeworx gateway returned HTTP ${status}: ${firstLine(out.text)}`, { status }));
+}
+
+function localInitialize(params) {
+  return {
+    protocolVersion: (params && params.protocolVersion) || '2025-06-18',
+    capabilities: { tools: {} },
+    serverInfo: { name: PACKAGE_NAME, version: VERSION },
+  };
+}
+
+const scopedInstructions = () =>
+  `${PACKAGE_NAME} forwards to the Pipeworx gateway and lists only the ${SLUG} pack's tools. `
+  + 'Set PIPEWORX_META_TOOLS=1 to also list ask_pipeworx and the other gateway-wide tools.';
+
+/** `<host name> (via pipeworx-standalone)`. The slug stays OUT of the name: the
+ *  gateway's scanner-name check substring-matches words like poll/watch/index. */
+export function bridgedClientName(name) {
+  const n = typeof name === 'string' && name.trim() ? name.trim() : 'unknown';
+  return n.includes(VIA) ? n : `${n} ${VIA}`;
+}
+
+/**
+ * Relay one JSON-RPC message to the gateway and return the response to write
+ * back, or null for a notification. Never throws.
+ *
+ * @param {object} message  a parsed JSON-RPC request or notification
+ * @param {{cfg?: object, warn?: (line: string) => void}} [opts]
+ */
+export async function relay(message, opts = {}) {
+  const cfg = opts.cfg || bridgeConfig();
+  const warn = opts.warn || ((line) => process.stderr.write(`${line}\n`));
+  if (!message || typeof message !== 'object' || message.jsonrpc !== '2.0' || typeof message.method !== 'string') {
+    const id = message && typeof message === 'object' && 'id' in message ? message.id : null;
+    return rpcError(id ?? null, -32600, 'Invalid Request');
+  }
+  const isNotification = !('id' in message) || message.id === undefined;
+  const id = message.id;
+
+  if (isNotification) {
+    const out = await postToGateway(message, cfg);
+    if (out.kind !== 'http') warn(`${PACKAGE_NAME}: notification ${message.method} not delivered: ${unreachableText(cfg, out)}`);
+    return null;
+  }
+
+  if (message.method === 'initialize') {
+    const params = { ...(message.params || {}) };
+    params.clientInfo = { ...(params.clientInfo || {}), name: bridgedClientName(params.clientInfo && params.clientInfo.name) };
+    if (!params.clientInfo.version) params.clientInfo.version = '0';
+    const out = await postToGateway({ ...message, params }, cfg);
+    noteTier(out, cfg, warn);
+    if (out.kind === 'http' && out.body && out.body.result && typeof out.body.result === 'object') {
+      const result = { ...out.body.result, serverInfo: { name: PACKAGE_NAME, version: VERSION } };
+      if (!cfg.metaTools) result.instructions = scopedInstructions();
+      return rpcResult(id, result);
+    }
+    // The host must still start: answer locally and let the calls report the
+    // gateway problem when they happen.
+    warn(`${PACKAGE_NAME}: initialize answered locally -- ${out.kind === 'http' ? `gateway HTTP ${out.status}` : unreachableText(cfg, out)}`);
+    return rpcResult(id, { ...localInitialize(message.params), instructions: scopedInstructions() });
+  }
+
+  if (message.method === 'tools/list') {
+    const out = await postToGateway(message, cfg);
+    noteTier(out, cfg, warn);
+    const listed = out.kind === 'http' && out.body && out.body.result && Array.isArray(out.body.result.tools)
+      ? out.body.result : null;
+    if (listed) {
+      if (cfg.metaTools) return rpcResult(id, listed);
+      const own = listed.tools.filter((t) => t && t._meta && (t._meta.pack === GATEWAY_SLUG || t._meta.pack === SLUG));
+      if (own.length > 0) return rpcResult(id, { ...listed, tools: own });
+      warn(`${PACKAGE_NAME}: the gateway listed no ${SLUG} tools; serving the tool list bundled with this package`);
+    } else {
+      warn(`${PACKAGE_NAME}: tools/list served from the snapshot bundled with this package -- ${out.kind === 'http' ? `gateway HTTP ${out.status}` : unreachableText(cfg, out)}`);
+    }
+    return rpcResult(id, { tools });
+  }
+
+  if (message.method === 'tools/call') {
+    const out = await postToGateway(message, cfg);
+    noteTier(out, cfg, warn);
+    return toolsCallResponse(id, out, cfg);
+  }
+
+  // Everything else (ping, resources/*, prompts/*, ...): relay as-is.
+  const out = await postToGateway(message, cfg);
+  noteTier(out, cfg, warn);
+  if (out.kind === 'http' && out.body && out.body.jsonrpc === '2.0') return { ...out.body, id };
+  if (message.method === 'ping') return rpcResult(id, {});
+  return rpcError(id, -32603, out.kind === 'http'
+    ? `The Pipeworx gateway returned HTTP ${out.status}: ${firstLine(out.text)}`
+    : unreachableText(cfg, out));
+}
+
+/**
+ * Call one of this pack's tools through the gateway -- the `{tools, callTool}`
+ * shape earlier versions of this package exported. Resolves with the tool's
+ * structured result; rejects with the gateway's message on any error.
+ *
+ * @param {string} name
+ * @param {Record<string, unknown>} [args]
+ * @param {{apiKey?: string, gatewayUrl?: string, timeoutMs?: number}} [opts]
+ *        apiKey defaults to process.env.PIPEWORX_API_KEY.
+ */
+export async function callTool(name, args = {}, opts = {}) {
+  const cfg = bridgeConfig(process.env, opts);
+  const res = await relay({ jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name, arguments: args } }, { cfg });
+  if (res.error) throw new Error(res.error.message);
+  const result = res.result || {};
+  const text = Array.isArray(result.content)
+    ? result.content.filter((c) => c && c.type === 'text').map((c) => c.text).join('\n')
+    : '';
+  if (result.isError) throw new Error(text || `${name} failed`);
+  if (result.structuredContent !== undefined) return result.structuredContent;
+  try { return JSON.parse(text); } catch { return text; }
+}
+
+export default { tools, callTool };

package/package.json

@@ -1,32 +1,33 @@
 {
   "name": "@pipeworx/mcp-emoji",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Emoji MCP.",
   "type": "module",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./tools.json": "./tools.json",
+    "./package.json": "./package.json"
+  },
   "bin": {
     "mcp-emoji": "bin/cli.js"
   },
+  "files": ["bin/", "lib/", "tools.json", "server.json"],
+  "engines": {
+    "node": ">=18"
+  },
   "keywords": ["mcp", "mcp-server", "model-context-protocol", "pipeworx", "emoji"],
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pipeworx-io/mcp-emoji.git"
   },
-  "scripts": {
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "tsx": "^4.19.0"
-  },
-  "devDependencies": {
-    "typescript": "^5.9.3",
-    "@cloudflare/workers-types": "^4.20260405.1"
-  },
+  "mcpName": "io.github.pipeworx-io/emoji",
   "pipeworx": {
-    "sourceHash": "v1-f8fd279502161d14b1fbfcb0549fb621366b7278ae9eac09b927371b72f1c7c9",
-    "sourceCommit": "76aa8f5d9b5dc2f665563030647c68e661478864"
+    "mode": "gateway",
+    "slug": "emoji",
+    "gatewaySlug": "emoji",
+    "sourceHash": "v1-2508389de204072b689bde2c2a05b8e56789055403152c57556869a7a00f2046",
+    "sourceCommit": "bb047243cf27f32453103de186b8e6a8b6a1ce79"
   }
 }

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.pipeworx-io/emoji",
   "title": "Emoji",
   "description": "Emoji MCP.",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "websiteUrl": "https://pipeworx.io/packs/emoji",
   "repository": {
     "url": "https://github.com/pipeworx-io/mcp-emoji",

package/tools.json

@@ -0,0 +1,38 @@
+[
+  {
+    "name": "emoji_lookup",
+    "description": "Look up an emoji by :shortcode: (e.g. \":fire:\" or \"fire\") to get the character + keywords, OR pass an emoji character to get its shortcode/name. Keyless, offline.",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "input": {
+          "type": "string",
+          "description": "A :shortcode:, a bare shortcode, or an emoji character."
+        }
+      },
+      "required": [
+        "input"
+      ]
+    }
+  },
+  {
+    "name": "search_emoji",
+    "description": "Search emoji by keyword/name (e.g. \"party\", \"money\", \"animal\") and return matching emoji with shortcodes. Keyless, offline.",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "query": {
+          "type": "string",
+          "description": "A keyword to search."
+        },
+        "limit": {
+          "type": "number",
+          "description": "Max results (default 20)."
+        }
+      },
+      "required": [
+        "query"
+      ]
+    }
+  }
+]

package/src/index.ts

@@ -1,121 +0,0 @@
-interface McpToolDefinition {
-  name: string;
-  description: string;
-  /** Human-facing one-liner (fleet #1967). Optional; consumers fall back to
-   *  description. Kept in step with shared/src/types.ts — scripts/lib/
-   *  check-inlined-types.mjs reports drift at publish time. */
-  summary?: string;
-  inputSchema: {
-    type: 'object';
-    properties: Record<string, unknown>;
-    required?: string[];
-    anyOf?: Array<{ required: string[] }>;
-    oneOf?: Array<{ required: string[] }>;
-    allOf?: Array<{ required: string[] }>;
-  };
-  outputSchema?: Record<string, unknown>;
-}
-
-interface McpToolExport {
-  tools: McpToolDefinition[];
-  callTool: (name: string, args: Record<string, unknown>) => Promise<unknown>;
-  meter?: { credits: number };
-  cost?: Record<string, unknown>;
-  provider?: string;
-}
-
-/**
- * Emoji MCP.
- *
- * Keyless, offline: look up an emoji by :shortcode: (or reverse — get the
- * shortcode/name for an emoji character) and search emoji by keyword, from an
- * inlined table of common emoji. Pure lookup — no API, no key.
- */
-
-
-// [emoji, shortcode, keywords]
-const DATA: [string, string, string][] = [
-  ['😀', 'grinning', 'happy smile face'], ['😃', 'smiley', 'happy joy'], ['😄', 'smile', 'happy laugh'],
-  ['😁', 'grin', 'happy'], ['😂', 'joy', 'laugh cry tears funny'], ['🤣', 'rofl', 'laugh rolling funny'],
-  ['🙂', 'slightly_smiling_face', 'smile'], ['😉', 'wink', 'flirt'], ['😊', 'blush', 'happy smile'],
-  ['😍', 'heart_eyes', 'love like'], ['😘', 'kissing_heart', 'kiss love'], ['😎', 'sunglasses', 'cool'],
-  ['🤔', 'thinking', 'think hmm consider'], ['😐', 'neutral_face', 'meh'], ['🙄', 'roll_eyes', 'annoyed'],
-  ['😴', 'sleeping', 'sleep tired zzz'], ['😭', 'sob', 'cry sad tears'], ['😢', 'cry', 'sad tear'],
-  ['😅', 'sweat_smile', 'relief nervous'], ['😤', 'triumph', 'angry proud'], ['😡', 'rage', 'angry mad'],
-  ['🥳', 'partying_face', 'party celebrate'], ['🤯', 'exploding_head', 'mind blown shock'], ['😱', 'scream', 'fear shock'],
-  ['🤗', 'hugs', 'hug'], ['🤩', 'star_struck', 'excited amazed'], ['😇', 'innocent', 'angel'],
-  ['👍', 'thumbsup', 'yes good approve like'], ['👎', 'thumbsdown', 'no bad dislike'], ['👏', 'clap', 'applause bravo'],
-  ['🙏', 'pray', 'please thanks hope'], ['🙌', 'raised_hands', 'celebrate praise'], ['👋', 'wave', 'hello bye hi'],
-  ['🤝', 'handshake', 'deal agree'], ['✌️', 'v', 'peace victory'], ['🤞', 'crossed_fingers', 'luck hope'],
-  ['💪', 'muscle', 'strong flex gym'], ['👀', 'eyes', 'look see watch'], ['🧠', 'brain', 'smart think'],
-  ['❤️', 'heart', 'love red'], ['🧡', 'orange_heart', 'love'], ['💛', 'yellow_heart', 'love'],
-  ['💚', 'green_heart', 'love'], ['💙', 'blue_heart', 'love'], ['💜', 'purple_heart', 'love'],
-  ['🖤', 'black_heart', 'love'], ['💔', 'broken_heart', 'sad heartbreak'], ['💯', '100', 'perfect score keep it'],
-  ['🔥', 'fire', 'lit hot flame'], ['✨', 'sparkles', 'shine magic new'], ['⭐', 'star', 'favorite'],
-  ['🎉', 'tada', 'party celebrate congrats'], ['🎊', 'confetti_ball', 'party celebrate'], ['🎈', 'balloon', 'party'],
-  ['🚀', 'rocket', 'launch ship fast space'], ['💡', 'bulb', 'idea light'], ['⚡', 'zap', 'lightning fast power'],
-  ['💰', 'moneybag', 'money cash rich'], ['💸', 'money_with_wings', 'spend money'], ['💵', 'dollar', 'money cash'],
-  ['📈', 'chart_with_upwards_trend', 'growth up stocks'], ['📉', 'chart_with_downwards_trend', 'down loss'],
-  ['✅', 'white_check_mark', 'yes done correct ok'], ['❌', 'x', 'no wrong cancel'], ['⚠️', 'warning', 'caution alert'],
-  ['❓', 'question', 'help ask'], ['❗', 'exclamation', 'important'], ['🔔', 'bell', 'notification alert'],
-  ['🔒', 'lock', 'secure private'], ['🔑', 'key', 'password access'], ['🛠️', 'hammer_and_wrench', 'tools fix build'],
-  ['🐶', 'dog', 'puppy pet'], ['🐱', 'cat', 'kitten pet'], ['🦊', 'fox', 'animal'], ['🐻', 'bear', 'animal'],
-  ['🦁', 'lion', 'animal'], ['🐸', 'frog', 'animal'], ['🐢', 'turtle', 'slow animal'], ['🦄', 'unicorn', 'magic'],
-  ['🐝', 'bee', 'insect'], ['🦋', 'butterfly', 'insect'], ['🌍', 'earth_africa', 'world globe planet'],
-  ['🌙', 'crescent_moon', 'night'], ['☀️', 'sunny', 'sun weather'], ['☁️', 'cloud', 'weather'],
-  ['🌧️', 'rain_cloud', 'rain weather'], ['❄️', 'snowflake', 'snow cold winter'], ['🌈', 'rainbow', 'pride color'],
-  ['🍕', 'pizza', 'food'], ['🍔', 'hamburger', 'food burger'], ['🌮', 'taco', 'food'], ['🍣', 'sushi', 'food'],
-  ['☕', 'coffee', 'drink caffeine'], ['🍺', 'beer', 'drink'], ['🍷', 'wine_glass', 'drink'], ['🎂', 'birthday', 'cake party'],
-  ['🍎', 'apple', 'fruit food'], ['🥑', 'avocado', 'food'], ['⚽', 'soccer', 'football sport'], ['🏀', 'basketball', 'sport'],
-  ['🎮', 'video_game', 'gaming play'], ['🎵', 'musical_note', 'music song'], ['📱', 'iphone', 'phone mobile'],
-  ['💻', 'computer', 'laptop code'], ['⌨️', 'keyboard', 'type code'], ['📧', 'email', 'mail message'],
-  ['📌', 'pushpin', 'pin location'], ['📎', 'paperclip', 'attach'], ['🔗', 'link', 'url chain'],
-  ['🎯', 'dart', 'target goal bullseye'], ['🏆', 'trophy', 'win award champion'], ['🥇', 'first_place_medal', 'gold win'],
-];
-
-const byShort = new Map<string, [string, string, string]>();
-const byEmoji = new Map<string, [string, string, string]>();
-for (const d of DATA) { byShort.set(d[1], d); byEmoji.set(d[0], d); }
-
-const tools: McpToolExport['tools'] = [
-  {
-    name: 'emoji_lookup',
-    description: 'Look up an emoji by :shortcode: (e.g. ":fire:" or "fire") to get the character + keywords, OR pass an emoji character to get its shortcode/name. Keyless, offline.',
-    inputSchema: { type: 'object', properties: { input: { type: 'string', description: 'A :shortcode:, a bare shortcode, or an emoji character.' } }, required: ['input'] },
-  },
-  {
-    name: 'search_emoji',
-    description: 'Search emoji by keyword/name (e.g. "party", "money", "animal") and return matching emoji with shortcodes. Keyless, offline.',
-    inputSchema: { type: 'object', properties: { query: { type: 'string', description: 'A keyword to search.' }, limit: { type: 'number', description: 'Max results (default 20).' } }, required: ['query'] },
-  },
-];
-
-async function callTool(name: string, args: Record<string, unknown>): Promise<unknown> {
-  switch (name) {
-    case 'emoji_lookup': {
-      const input = reqStr(args, 'input', '":fire:"').trim();
-      const short = input.replace(/^:|:$/g, '');
-      const byS = byShort.get(short.toLowerCase());
-      if (byS) return { input, found: true, emoji: byS[0], shortcode: byS[1], keywords: byS[2].split(' ') };
-      const byE = byEmoji.get(input) ?? byEmoji.get([...input][0]);
-      if (byE) return { input, found: true, emoji: byE[0], shortcode: byE[1], keywords: byE[2].split(' ') };
-      return { input, found: false, reason: 'Not in the emoji table. Try search_emoji by keyword.' };
-    }
-    case 'search_emoji': {
-      const q = reqStr(args, 'query', '"party"').toLowerCase();
-      const limit = Math.max(1, Math.min(100, typeof args.limit === 'number' ? args.limit : 20));
-      const hits = DATA.filter(([, s, k]) => s.includes(q) || k.includes(q)).slice(0, limit).map(([e, s, k]) => ({ emoji: e, shortcode: s, keywords: k.split(' ') }));
-      return { query: q, count: hits.length, results: hits };
-    }
-    default:
-      throw new Error(`Unknown tool: ${name}`);
-  }
-}
-
-function reqStr(args: Record<string, unknown>, key: string, ex: string): string {
-  const v = args[key];
-  if (typeof v !== 'string' || !v.trim()) throw new Error(`Required argument "${key}" is missing. Pass a string like ${ex}.`);
-  return v;
-}
-
-export default { tools, callTool, meter: { credits: 1 } } satisfies McpToolExport;

package/src/server.ts

@@ -1,45 +0,0 @@
-/**
- * Stdio MCP server entry point for @pipeworx/mcp-emoji.
- * Generated by scripts/publish-pack.sh — do not hand-edit in the pack repo;
- * edit scripts/publish-pack.sh (the server.ts heredoc) and republish instead.
- */
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import pack from './index.js';
-
-const server = new Server(
-  { name: '@pipeworx/mcp-emoji', version: '0.1.1' },
-  { capabilities: { tools: {} } },
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: pack.tools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    inputSchema: t.inputSchema,
-  })),
-}));
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-  try {
-    const result = await pack.callTool(name, (args ?? {}) as Record<string, unknown>);
-    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-  } catch (err) {
-    return {
-      content: [{ type: 'text', text: err instanceof Error ? err.message : String(err) }],
-      isError: true,
-    };
-  }
-});
-
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-
-main().catch((err) => {
-  console.error('Fatal error running server:', err);
-  process.exit(1);
-});

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": ["ES2022"],
-    "types": ["@cloudflare/workers-types"],
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true,
-    "outDir": "dist",
-    "rootDir": "src",
-    "declaration": true
-  },
-  "include": ["src"],
-  "exclude": ["src/server.ts"]
-}