noodleseed-cli 0.1.4

package/node_modules/@noodle-borg/protocol/dist/server.js

@@ -0,0 +1,89 @@
+import { Mcp20251125Adapter } from './adapters/mcp-2025-11-25.js';
+import { err, isRequest, JSON_RPC, ok, } from './jsonrpc.js';
+import { negotiate } from './negotiate.js';
+import { ProtocolRegistry } from './registry.js';
+/** Per-connection state: the protocol version negotiated at `initialize`. */
+export class McpSession {
+    adapter = undefined;
+}
+/**
+ * A transport-agnostic MCP server for one resolved artifact. `handleMessage` maps a parsed JSON-RPC
+ * message to a response (or `null` for notifications), dispatching to the session's negotiated
+ * protocol adapter. A stdio/HTTP transport that frames bytes and carries the `MCP-Protocol-Version`
+ * header is a separate, later layer.
+ */
+export class McpServer {
+    #artifact;
+    #deps;
+    #registry;
+    constructor(options) {
+        this.#artifact = options.artifact;
+        this.#deps = options.deps;
+        this.#registry = options.registry ?? new ProtocolRegistry([new Mcp20251125Adapter()]);
+    }
+    /** Open a new session (one per client connection). */
+    createSession() {
+        return new McpSession();
+    }
+    async handleMessage(session, message) {
+        // Notifications (no id) get no response. `notifications/initialized` and any other are no-ops.
+        if (!isRequest(message))
+            return null;
+        const { id, method } = message;
+        if (method === 'initialize') {
+            const params = (message.params ?? {});
+            const adapter = negotiate(this.#registry, params.protocolVersion);
+            session.adapter = adapter;
+            return ok(id, adapter.initializeResult(this.#artifact, params));
+        }
+        if (method === 'ping')
+            return ok(id, {});
+        if (method === 'tools/list' || method === 'tools/call') {
+            if (!session.adapter) {
+                return err(id, JSON_RPC.INVALID_REQUEST, `received "${method}" before initialization`);
+            }
+            if (method === 'tools/list') {
+                return ok(id, session.adapter.listTools(this.#artifact));
+            }
+            const paramsRecord = message.params;
+            if (!isRecord(paramsRecord)) {
+                return err(id, JSON_RPC.INVALID_PARAMS, '"tools/call" params must be an object');
+            }
+            if (typeof paramsRecord.name !== 'string') {
+                return err(id, JSON_RPC.INVALID_PARAMS, '"tools/call" requires a string "name"');
+            }
+            if (paramsRecord.arguments !== undefined && !isRecord(paramsRecord.arguments)) {
+                return err(id, JSON_RPC.INVALID_PARAMS, '"tools/call" arguments must be an object');
+            }
+            const params = paramsRecord.arguments === undefined
+                ? { name: paramsRecord.name }
+                : { name: paramsRecord.name, arguments: paramsRecord.arguments };
+            const outcome = await session.adapter.callTool(this.#artifact, params, this.#deps);
+            return 'result' in outcome
+                ? ok(id, outcome.result)
+                : { jsonrpc: '2.0', id, error: outcome.error };
+        }
+        return err(id, JSON_RPC.METHOD_NOT_FOUND, `unknown method "${method}"`);
+    }
+    /**
+     * Handle a single message without a caller-held session — for stateless transports (e.g. remote
+     * HTTP). `initialize` negotiates from the message body; every other request negotiates from
+     * `requestedVersion` (the transport's `MCP-Protocol-Version` header), defaulting to the stable
+     * latest when absent. No session state is retained between calls.
+     */
+    async handleStateless(message, requestedVersion) {
+        const session = new McpSession();
+        if (isRequest(message) && message.method !== 'initialize') {
+            session.adapter = negotiate(this.#registry, requestedVersion);
+        }
+        return this.handleMessage(session, message);
+    }
+    /** Whether the server supports a given protocol version (an exact registered adapter). */
+    supports(version) {
+        return this.#registry.get(version) !== undefined;
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+//# sourceMappingURL=server.js.map

package/node_modules/@noodle-borg/protocol/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}

package/node_modules/@noodle-borg/protocol/dist/stateless.d.ts

@@ -0,0 +1,14 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type ServedArtifact } from './sdk-server.js';
+/**
+ * Serve a single already-parsed JSON-RPC request for one {@link ServedArtifact} over the MCP
+ * **Streamable HTTP** transport, statelessly. A fresh SDK server + transport are built per request
+ * (`sessionIdGenerator: undefined`), so no session state is retained between calls; `enableJsonResponse`
+ * returns one `application/json` JSON-RPC response rather than an SSE stream. The transport owns version
+ * negotiation and framing; the caller's HTTP front-door owns origin/method/size guards.
+ *
+ * `parsedBody` is the JSON already read by the front-door (so its body-size guard still applies). The
+ * transport writes the full HTTP response (status + headers + body), including `202` for a notification.
+ */
+export declare function handleStatelessHttp(target: ServedArtifact, req: IncomingMessage, res: ServerResponse, parsedBody: unknown): Promise<void>;
+//# sourceMappingURL=stateless.d.ts.map

package/node_modules/@noodle-borg/protocol/dist/stateless.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateless.d.ts","sourceRoot":"","sources":["../src/stateless.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAGjE,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtE;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,cAAc,EACtB,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,UAAU,EAAE,OAAO,GAClB,OAAO,CAAC,IAAI,CAAC,CAcf"}

package/node_modules/@noodle-borg/protocol/dist/stateless.js

@@ -0,0 +1,28 @@
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { buildMcpServer } from './sdk-server.js';
+/**
+ * Serve a single already-parsed JSON-RPC request for one {@link ServedArtifact} over the MCP
+ * **Streamable HTTP** transport, statelessly. A fresh SDK server + transport are built per request
+ * (`sessionIdGenerator: undefined`), so no session state is retained between calls; `enableJsonResponse`
+ * returns one `application/json` JSON-RPC response rather than an SSE stream. The transport owns version
+ * negotiation and framing; the caller's HTTP front-door owns origin/method/size guards.
+ *
+ * `parsedBody` is the JSON already read by the front-door (so its body-size guard still applies). The
+ * transport writes the full HTTP response (status + headers + body), including `202` for a notification.
+ */
+export async function handleStatelessHttp(target, req, res, parsedBody) {
+    const server = buildMcpServer(target);
+    // Omitting `sessionIdGenerator` selects stateless mode; `enableJsonResponse` returns one JSON-RPC
+    // object rather than an SSE stream. (We can't pass `sessionIdGenerator: undefined` explicitly under
+    // `exactOptionalPropertyTypes`.)
+    const transport = new StreamableHTTPServerTransport({ enableJsonResponse: true });
+    res.on('close', () => {
+        void transport.close();
+        void server.close();
+    });
+    // The SDK transport's optional `onclose`/`onerror`/`onmessage` are `T | undefined`, which trips
+    // `exactOptionalPropertyTypes` against the `Transport` interface; it is a valid Transport at runtime.
+    await server.connect(transport);
+    await transport.handleRequest(req, res, parsedBody);
+}
+//# sourceMappingURL=stateless.js.map

package/node_modules/@noodle-borg/protocol/dist/stateless.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateless.js","sourceRoot":"","sources":["../src/stateless.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,EAAE,MAAM,oDAAoD,CAAC;AAEnG,OAAO,EAAE,cAAc,EAAuB,MAAM,iBAAiB,CAAC;AAEtE;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,MAAsB,EACtB,GAAoB,EACpB,GAAmB,EACnB,UAAmB;IAEnB,MAAM,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;IACtC,kGAAkG;IAClG,oGAAoG;IACpG,iCAAiC;IACjC,MAAM,SAAS,GAAG,IAAI,6BAA6B,CAAC,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC,CAAC;IAClF,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;QACnB,KAAK,SAAS,CAAC,KAAK,EAAE,CAAC;QACvB,KAAK,MAAM,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC,CAAC,CAAC;IACH,gGAAgG;IAChG,sGAAsG;IACtG,MAAM,MAAM,CAAC,OAAO,CAAC,SAAsB,CAAC,CAAC;IAC7C,MAAM,SAAS,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC;AACtD,CAAC"}

package/node_modules/@noodle-borg/protocol/dist/widget/bootstrap.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The widget runtime bootstrap — the single source of truth for the script that runs INSIDE a widget's
+ * sandboxed iframe, after the vendored `@modelcontextprotocol/ext-apps` bundle. It is exported as a string
+ * (`WIDGET_BOOTSTRAP_SOURCE`) so that:
+ *   1. `./inject.ts` concatenates it after the bundle into one inline `<script type="module">` at serve time
+ *      (shared runtime infrastructure — never stored per artifact, never counted against the author cap), and
+ *   2. `../../test/widget-runtime.test.ts` `eval`s the EXACT shipped source against a happy-dom document + a
+ *      mock host, so the runtime is regression-tested with zero drift and without a build step.
+ *
+ * It opens the host bridge (so the host reveals + sizes the frame), applies the host theme, surfaces the
+ * tool-call result AND input into the author's declarative `[data-bind*]` elements, and dispatches CSP-safe
+ * `[data-action]` buttons to the host bridge. The shapes here are pinned to ext-apps v1.7.4 / SEP-1865:
+ * `ontoolinput.params.arguments`, `ontoolresult.params` = `CallToolResult`, `callServerTool({name,arguments})`
+ * → `CallToolResult`, `openLink({url})`, `requestDisplayMode({mode})`,
+ * `downloadFile({contents:[EmbeddedResource]})`. See docs/spec/apps-and-authoring.md and
+ * docs/decisions/0022-adopt-mcp-ui-for-apps-widgets.md (W2.5).
+ *
+ * CONSTRAINTS (enforced by review + tests): contains NO `</script>` (it is concatenated raw, not escaped) and
+ * NO `${...}` (it lives inside a TypeScript template literal — `${` would be interpolated). Author-facing
+ * placeholders use `{{dotted.path}}`, resolved client-side against the bound tool result, so the server-side
+ * widget body stays a constant literal and our `${...}` expression language never touches widget HTML.
+ */
+export declare const WIDGET_BOOTSTRAP_SOURCE: string;
+//# sourceMappingURL=bootstrap.d.ts.map

package/node_modules/@noodle-borg/protocol/dist/widget/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/widget/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,uBAAuB,EAAE,MA6IrC,CAAC"}

package/node_modules/@noodle-borg/protocol/dist/widget/bootstrap.js

@@ -0,0 +1,165 @@
+/**
+ * The widget runtime bootstrap — the single source of truth for the script that runs INSIDE a widget's
+ * sandboxed iframe, after the vendored `@modelcontextprotocol/ext-apps` bundle. It is exported as a string
+ * (`WIDGET_BOOTSTRAP_SOURCE`) so that:
+ *   1. `./inject.ts` concatenates it after the bundle into one inline `<script type="module">` at serve time
+ *      (shared runtime infrastructure — never stored per artifact, never counted against the author cap), and
+ *   2. `../../test/widget-runtime.test.ts` `eval`s the EXACT shipped source against a happy-dom document + a
+ *      mock host, so the runtime is regression-tested with zero drift and without a build step.
+ *
+ * It opens the host bridge (so the host reveals + sizes the frame), applies the host theme, surfaces the
+ * tool-call result AND input into the author's declarative `[data-bind*]` elements, and dispatches CSP-safe
+ * `[data-action]` buttons to the host bridge. The shapes here are pinned to ext-apps v1.7.4 / SEP-1865:
+ * `ontoolinput.params.arguments`, `ontoolresult.params` = `CallToolResult`, `callServerTool({name,arguments})`
+ * → `CallToolResult`, `openLink({url})`, `requestDisplayMode({mode})`,
+ * `downloadFile({contents:[EmbeddedResource]})`. See docs/spec/apps-and-authoring.md and
+ * docs/decisions/0022-adopt-mcp-ui-for-apps-widgets.md (W2.5).
+ *
+ * CONSTRAINTS (enforced by review + tests): contains NO `</script>` (it is concatenated raw, not escaped) and
+ * NO `${...}` (it lives inside a TypeScript template literal — `${` would be interpolated). Author-facing
+ * placeholders use `{{dotted.path}}`, resolved client-side against the bound tool result, so the server-side
+ * widget body stays a constant literal and our `${...}` expression language never touches widget HTML.
+ */
+export const WIDGET_BOOTSTRAP_SOURCE = `
+(async () => {
+  const E = globalThis.ExtApps;
+  if (!E || !E.App) return;
+  const app = new E.App({ name: 'noodle-widget', version: '1' }, {}, { autoResize: true });
+
+  const get = (o, p) => String(p).split('.').reduce((x, k) => (x == null ? undefined : x[k]), o);
+
+  // Resolve {{dotted.path}} placeholders in a string against the current bound data (no regex: avoids
+  // template-literal escaping, and is robust to stray braces).
+  function tmpl(s, data) {
+    s = String(s);
+    let out = '';
+    let i = 0;
+    while (i < s.length) {
+      const open = s.indexOf('{{', i);
+      if (open === -1) { out += s.slice(i); break; }
+      out += s.slice(i, open);
+      const close = s.indexOf('}}', open + 2);
+      if (close === -1) { out += s.slice(open); break; }
+      const v = get(data, s.slice(open + 2, close).trim());
+      out += (v == null ? '' : String(v));
+      i = close + 2;
+    }
+    return out;
+  }
+  // Resolve {{...}} throughout a parsed-JSON args value (string leaves only).
+  function resolveArgs(v, data) {
+    if (typeof v === 'string') return tmpl(v, data);
+    if (Array.isArray(v)) return v.map((x) => resolveArgs(x, data));
+    if (v && typeof v === 'object') {
+      const out = {};
+      for (const k of Object.keys(v)) out[k] = resolveArgs(v[k], data);
+      return out;
+    }
+    return v;
+  }
+
+  // Tool RESULT (structuredContent, else the first text block as JSON) → [data-bind] / [data-bind-if].
+  function bind(data) {
+    if (data == null) return;
+    globalThis.__noodleData = data;
+    for (const el of document.querySelectorAll('[data-bind]')) {
+      const v = get(data, el.getAttribute('data-bind'));
+      if (v !== undefined && v !== null) el.textContent = String(v);
+    }
+    for (const el of document.querySelectorAll('[data-bind-if]')) {
+      const v = get(data, el.getAttribute('data-bind-if'));
+      el.hidden = !(v !== undefined && v !== null && v !== false && v !== '');
+    }
+    try { globalThis.dispatchEvent(new CustomEvent('noodle:data', { detail: data })); } catch (e) {}
+  }
+  // Tool-call ARGUMENTS (what the model passed) → [data-bind-input] (mirrors bind()).
+  function bindInput(args) {
+    if (args == null) return;
+    globalThis.__noodleInput = args;
+    for (const el of document.querySelectorAll('[data-bind-input]')) {
+      const v = get(args, el.getAttribute('data-bind-input'));
+      if (v !== undefined && v !== null) el.textContent = String(v);
+    }
+  }
+  function fromResult(r) {
+    if (!r) return null;
+    if (r.structuredContent != null) return r.structuredContent;
+    const t = r.content && r.content[0] && r.content[0].text;
+    if (typeof t === 'string') { try { return JSON.parse(t); } catch (e) { return null; } }
+    return null;
+  }
+  function theme(ctx) {
+    try {
+      // host-context-changed may be a PARTIAL update (theme/styles independently optional) — only touch the
+      // theme class when 'theme' is actually present, so a styles-only update never flips a dark widget back
+      // to light.
+      if (ctx && ctx.theme !== undefined) {
+        document.documentElement.classList.toggle('dark', ctx.theme === 'dark');
+      }
+      const styles = ctx && ctx.styles;
+      if (styles && styles.variables && E.applyHostStyleVariables) E.applyHostStyleVariables(styles.variables);
+      if (styles && styles.css && styles.css.fonts && E.applyHostFonts) E.applyHostFonts(styles.css.fonts);
+    } catch (e) {}
+  }
+  function clearBusy() {
+    for (const el of document.querySelectorAll('[aria-busy="true"]')) {
+      el.disabled = false; el.removeAttribute('aria-busy');
+    }
+  }
+
+  // CSP-safe declarative actions (no inline handlers). A [data-action] element drives the host bridge:
+  //   send|context → conversation;  call → server tools/call (re-binds the result in place);
+  //   open → external link;  display → display mode;  download → host-mediated file export.
+  function actOnce(el) {
+    const action = el.getAttribute('data-action');
+    const text = el.getAttribute('data-action-text') || el.textContent || '';
+    const data = globalThis.__noodleData;
+    try {
+      if (action === 'send') {
+        app.sendMessage({ role: 'user', content: [{ type: 'text', text }] });
+      } else if (action === 'context') {
+        app.updateModelContext({ content: [{ type: 'text', text }] });
+      } else if (action === 'call') {
+        const name = el.getAttribute('data-action-tool');
+        if (!name) return;
+        let args = {};
+        const raw = el.getAttribute('data-action-args');
+        if (raw) { try { args = resolveArgs(JSON.parse(raw), data); } catch (e) { args = {}; } }
+        el.disabled = true; el.setAttribute('aria-busy', 'true');
+        Promise.resolve(app.callServerTool({ name, arguments: args }))
+          .then((r) => bind(fromResult(r)))
+          .catch(() => {})
+          .then(() => { el.disabled = false; el.removeAttribute('aria-busy'); });
+      } else if (action === 'open') {
+        const url = el.getAttribute('data-action-href');
+        if (url) app.openLink({ url });
+      } else if (action === 'display') {
+        app.requestDisplayMode({ mode: el.getAttribute('data-action-mode') || 'fullscreen' });
+      } else if (action === 'download') {
+        const file = el.getAttribute('data-action-file') || 'download.txt';
+        const mimeType = el.getAttribute('data-action-mime') || 'text/plain';
+        const content = tmpl(el.getAttribute('data-action-content') || '', data);
+        app.downloadFile({
+          contents: [{ type: 'resource', resource: { uri: 'ui://download/' + file, mimeType, text: content } }],
+        });
+      }
+    } catch (e) {}
+  }
+  function wireActions() {
+    for (const el of document.querySelectorAll('[data-action]')) {
+      el.addEventListener('click', () => actOnce(el));
+    }
+  }
+
+  // Register handlers BEFORE connect() so no one-shot host notification is missed.
+  app.ontoolresult = (p) => bind(fromResult(p));
+  app.ontoolinput = (p) => bindInput(p && p.arguments);
+  app.ontoolcancelled = () => clearBusy();
+  app.onhostcontextchanged = theme;
+  app.onteardown = () => { try { clearBusy(); } catch (e) {} return {}; };
+  wireActions();
+  try { await app.connect(); } catch (e) {}
+  try { theme(app.getHostContext && app.getHostContext()); } catch (e) {}
+})();
+`;
+//# sourceMappingURL=bootstrap.js.map

package/node_modules/@noodle-borg/protocol/dist/widget/bootstrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/widget/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6I9C,CAAC"}

package/node_modules/@noodle-borg/protocol/dist/widget/ext-apps-bundle.d.ts

@@ -0,0 +1,4 @@
+export declare const EXT_APPS_VERSION = "1.7.4";
+/** The minified ext-apps browser bundle, rewritten to assign `globalThis.ExtApps`. */
+export declare const EXT_APPS_BUNDLE: string;
+//# sourceMappingURL=ext-apps-bundle.d.ts.map

package/node_modules/@noodle-borg/protocol/dist/widget/ext-apps-bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ext-apps-bundle.d.ts","sourceRoot":"","sources":["../../src/widget/ext-apps-bundle.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB,UAAU,CAAC;AAExC,sFAAsF;AACtF,eAAO,MAAM,eAAe,EAAE,MAAmtkU,CAAC"}