@guuey/create-agentic-app 0.1.0

package/dist/templates/openai-agents-sdk/pnpm-workspace.yaml

@@ -0,0 +1,24 @@
+packages:
+  - "mcps/*"
+  - "web"
+
+# pnpm 11 default `strictDepBuilds: true` blocks install scripts for any
+# dependency with a build script (esbuild's native binary fetch, sharp,
+# etc.) unless individually allowlisted, and fails the whole `install`
+# with ERR_PNPM_IGNORED_BUILDS otherwise. Scaffolded apps pull in build-
+# script deps transitively (tsup/vite -> esbuild, mcp/ui deps, etc.) that
+# we can't enumerate up front, so match pnpm 9/10 behavior here.
+strictDepBuilds: false
+
+# pnpm 11 default `verifyDepsBeforeRun: 'install'` re-verifies the
+# lockfile against supply-chain policies (including minimumReleaseAge)
+# before every `pnpm run <script>`, hitting the registry even for
+# already-installed deps. That check 404s for any dependency that only
+# exists as a local tarball (not yet published), which is expected
+# during local/dev/CI installs. Restore pnpm 9/10 behavior: only verify
+# on an explicit `pnpm install`.
+verifyDepsBeforeRun: false
+
+# See above — same registry-lookback problem hits a plain `pnpm install`
+# too when minimumReleaseAge is nonzero; disable it for scaffolded apps.
+minimumReleaseAge: 0

package/dist/templates/openai-agents-sdk/prompts/system.md

@@ -0,0 +1,4 @@
+You are the agentic-app-template assistant. You have a todo tool server —
+use it to create, list, toggle, and delete the user's todos. When the ggui
+server is available, prefer rendering rich UI for lists and forms over
+plain text.

package/dist/templates/openai-agents-sdk/scripts/dev.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+// pnpm dev — boots the whole local stack. Ctrl-C tears everything down.
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+
+const procs = [];
+function boot(name, command, args, opts = {}) {
+  const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"], ...opts });
+  const prefix = `[${name}]`.padEnd(9);
+  child.stdout.on("data", (d) => process.stdout.write(String(d).replace(/^/gm, prefix)));
+  child.stderr.on("data", (d) => process.stderr.write(String(d).replace(/^/gm, prefix)));
+  child.on("exit", (code) => {
+    if (code !== 0 && !shuttingDown) shutdown(`${name} exited (${code})`, 1);
+  });
+  procs.push(child);
+}
+let shuttingDown = false;
+function shutdown(reason, code = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  console.log(`\n${reason} — shutting down`);
+  for (const p of procs) p.kill("SIGTERM");
+  setTimeout(() => process.exit(code), 500);
+}
+process.on("SIGINT", () => shutdown("interrupted"));
+process.on("SIGTERM", () => shutdown("terminated"));
+
+if (!existsSync(".env.local"))
+  console.warn("hint: cp .env.example .env.local and set your LLM key");
+
+boot("worker", "pnpm", ["exec", "tsup", "--watch"]); // rebuilds guuey.worker.js on change
+boot("agent", "pnpm", ["exec", "guuey", "dev", "--serve", "--port", "6790"]);
+boot("todo", "pnpm", ["--filter", "@agentic-app-template/todo-mcp", "dev"], {
+  env: { ...process.env, PORT: "6782" },
+});
+boot("ggui", "pnpm", ["exec", "ggui", "serve", "--mcp-only", "--dev-allow-all", "--port", "6781"], {
+  cwd: "ggui",
+});
+boot("web", "pnpm", ["--filter", "@agentic-app-template/web", "dev"], {
+  env: { ...process.env, PORT: "6890" },
+});
+
+console.log("\n  agent  http://localhost:6790   todo-mcp http://localhost:6782");
+console.log("  ggui   http://localhost:6781   web      http://localhost:6890\n");

package/dist/templates/openai-agents-sdk/src/agent-config.ts

@@ -0,0 +1,70 @@
+/**
+ * Snapshot + system-prompt + MCP-endpoint resolution shared by both framework
+ * overlays. Duplicated verbatim in `templates-src/frameworks/openai-agents-sdk`
+ * by design — template code must be self-contained (no cross-overlay imports),
+ * so keep the two copies byte-identical when editing either one.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseGuueyJson, type GuueyAgent } from "@guuey/config";
+import type { Invoke } from "@guuey/worker";
+
+/** GUUEY_AGENT_SNAPSHOT (set by the platform pod and by `guuey dev`) wins; guuey.json is the fallback. */
+export function loadAgent(invoke: Invoke): GuueyAgent {
+  const env = process.env.GUUEY_AGENT_SNAPSHOT;
+  if (env) return JSON.parse(env) as GuueyAgent;
+  const raw = JSON.parse(readFileSync(join(invoke.fs.app, "guuey.json"), "utf8"));
+  return parseGuueyJson(raw).agent;
+}
+
+export function systemPrompt(invoke: Invoke, agent: GuueyAgent): string | undefined {
+  const sp = agent.systemPrompt;
+  if (typeof sp === "string") return sp;
+  if (sp?.file) return readFileSync(join(invoke.fs.app, sp.file), "utf8");
+  return undefined;
+}
+
+/**
+ * One resolved MCP endpoint this worker may connect to. `transport` rides
+ * alongside `url`/`headers` (not hardcoded to `"http"`) because a federation
+ * credential file — `<session>/.guuey/credentials/<name>.json`, shape
+ * `{url, transport, headers}` per `@guuey/host`'s `CredentialFile` — may
+ * resolve a server onto the `sse` transport arm.
+ */
+export interface McpEndpoint {
+  url: string;
+  transport: "http" | "sse";
+  headers: Record<string, string>;
+}
+
+/** Lowered entries are `external`; federation credentials (if any) arrive as per-session files. */
+export function mcpEndpoints(invoke: Invoke, agent: GuueyAgent): Record<string, McpEndpoint> {
+  const out: Record<string, McpEndpoint> = {};
+  for (const [name, entry] of Object.entries(agent.mcpServers ?? {})) {
+    if (entry.kind !== "external") continue; // hosted/proxied are lowered to external before a worker ever runs
+    let url = entry.url;
+    let transport: "http" | "sse" = entry.transport ?? "http";
+    let headers: Record<string, string> = { ...(entry.headers ?? {}) };
+    try {
+      const cred = JSON.parse(
+        readFileSync(join(invoke.fs.session, ".guuey", "credentials", `${name}.json`), "utf8")
+      ) as { url: string; transport: "http" | "sse"; headers: Record<string, string> };
+      url = cred.url;
+      transport = cred.transport;
+      headers = cred.headers;
+    } catch {
+      // no credential file — plain external endpoint; static headers apply
+    }
+    out[name] = { url, transport, headers };
+  }
+  return out;
+}
+
+/** Fold prior turns into a prompt preamble (v1 keep-it-simple history handling). */
+export function withHistory(invoke: Invoke): string {
+  if (invoke.history.length === 0) return invoke.input;
+  const lines = invoke.history.map(
+    (h) => `${h.role === "agent" ? "Assistant" : "User"}: ${h.text}`
+  );
+  return `<conversation_history>\n${lines.join("\n")}\n</conversation_history>\n\n${invoke.input}`;
+}

package/dist/templates/openai-agents-sdk/src/worker.ts

@@ -0,0 +1,75 @@
+/**
+ * agentic-app-template's code-mode worker entry (`@openai/agents`). Mirrors
+ * `@guuey/host`'s `run-openai.ts` — the platform's own OpenAI wiring over this
+ * exact snapshot shape: build an `Agent` from the resolved system prompt +
+ * MCP endpoints, run it streamed, emit every raw `RunStreamEvent` to the
+ * Router via `emit.native`, and resolve the turn's final text from
+ * `stream.finalOutput`.
+ *
+ * `MaxTurnsExceededError` handling mirrors `run-openai.ts`'s INTENT — there
+ * max-turns is a soft terminal (`done(finalText, "max_turns")` after a
+ * sentinel), NOT a hard `error`; the partial output is still the turn's
+ * result. `serveNative`'s handler contract has neither a stopReason nor a
+ * sentinel channel (a return is always `done(.., "end_turn")`; a throw is a
+ * hard `error` that would discard the partial text), so the cutoff is made
+ * visible by appending a note to the returned result instead of rethrowing.
+ */
+import { Agent, MaxTurnsExceededError, MCPServerStreamableHttp, run } from "@openai/agents";
+import type { MCPServer } from "@openai/agents";
+import { serveNative } from "@guuey/worker";
+import { loadAgent, systemPrompt, mcpEndpoints, withHistory } from "./agent-config.js";
+
+await serveNative(
+  async (invoke, emit) => {
+    const agent = loadAgent(invoke);
+    const endpoints = mcpEndpoints(invoke, agent);
+    const mcpServers: MCPServerStreamableHttp[] = Object.entries(endpoints).map(
+      ([name, ep]) =>
+        new MCPServerStreamableHttp({
+          url: ep.url,
+          name,
+          ...(Object.keys(ep.headers).length > 0 ? { requestInit: { headers: ep.headers } } : {}),
+        })
+    );
+
+    try {
+      for (const server of mcpServers) {
+        await server.connect();
+      }
+
+      const sdkAgent = new Agent({
+        name: "guuey-agent",
+        instructions: systemPrompt(invoke, agent) ?? "You are a helpful assistant.",
+        mcpServers: mcpServers as MCPServer[],
+        ...(agent.model ? { model: agent.model } : {}),
+      });
+
+      const stream = await run(sdkAgent, withHistory(invoke), {
+        stream: true,
+        ...(agent.runtime?.maxTurns ? { maxTurns: agent.runtime.maxTurns } : {}),
+      });
+
+      for await (const event of stream) {
+        emit.native(JSON.parse(JSON.stringify(event)));
+      }
+
+      try {
+        await stream.completed;
+      } catch (err) {
+        if (err instanceof MaxTurnsExceededError) {
+          // Soft terminal (see module doc): keep whatever partial output the
+          // stream produced and make the cutoff visible in the result text.
+          const partial = typeof stream.finalOutput === "string" ? stream.finalOutput : "";
+          const note = "[agent stopped: maxTurns limit reached]";
+          return partial ? `${partial}\n\n${note}` : note;
+        }
+        throw err;
+      }
+
+      return typeof stream.finalOutput === "string" ? stream.finalOutput : "";
+    } finally {
+      await Promise.allSettled(mcpServers.map((s) => s.close()));
+    }
+  },
+  { framework: "openai-agents-sdk", sdkName: "@openai/agents" }
+);

package/dist/templates/openai-agents-sdk/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/templates/openai-agents-sdk/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: { "guuey.worker": "src/worker.ts" },
+  format: ["esm"],
+  outDir: ".",
+  clean: false,
+  noExternal: [/./], // bundle everything — the deploy tarball must be runnable via `node guuey.worker.js`
+});

package/dist/templates/openai-agents-sdk/web/.env.example

@@ -0,0 +1,17 @@
+# Vite env for the web chat client. Copy to `web/.env.local` and UNCOMMENT
+# the vars you want to override. (Vite reads env files from this directory —
+# not the project root. Keep unused vars commented out: an empty
+# `VITE_X=` declaration loads as "" — not undefined.)
+
+# Agent base URL. Defaults to the local `guuey dev` router (:6790).
+# VITE_AGENT_ENDPOINT_URL=http://localhost:6790
+
+# Second-origin MCP-Apps sandbox page for @mcp-ui/client's <AppRenderer>.
+# The MCP Apps spec requires UI resources to mount from a DIFFERENT origin
+# than the app itself (double-iframe sandbox). In local dev this is served
+# automatically on http://127.0.0.1:6891/sandbox.html by the
+# sandboxProxyPlugin in vite.config.ts — leave unset. For a DEPLOYED build,
+# host ../sandbox-proxy.ts's sandbox page on its own origin and point this
+# at it; if unset in production, UI resources show a plain-text notice
+# instead of rendering.
+# VITE_SANDBOX_URL=https://sandbox.example.com/sandbox.html

package/dist/templates/openai-agents-sdk/web/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>agentic-app-template</title>
+    <meta name="description" content="Local dev chat client for your guuey agent." />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/dist/templates/openai-agents-sdk/web/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@agentic-app-template/web",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite --port 6890",
+    "build": "tsc && vite build",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@mcp-ui/client": "^7.1.1",
+    "@silverprotocol/core": "0.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "typescript": "^5.8.0",
+    "vite": "^6.0.0"
+  }
+}

package/dist/templates/openai-agents-sdk/web/sandbox-proxy.ts

@@ -0,0 +1,239 @@
+/**
+ * MCP-Apps sandbox proxy for local dev — a Vite plugin that serves the
+ * spec-canonical `sandbox.html` on a SECOND localhost port (:6891), i.e. a
+ * different origin from the SPA (:6890).
+ *
+ * # Why a second origin
+ *
+ * The MCP Apps spec's double-iframe sandbox architecture mandates that the
+ * host page and the sandbox iframe live on DIFFERENT origins: the host wraps
+ * the sandbox iframe, the sandbox iframe wraps the untrusted app HTML, and
+ * the origin split means a compromised app cannot reach the host's APIs via
+ * same-origin DOM access. `@mcp-ui/client`'s `<AppRenderer>` takes a
+ * `sandbox: { url }` prop pointing at this page. A different localhost PORT
+ * is a different origin, so one extra listener is all local dev needs.
+ *
+ * # Reference impl
+ *
+ * The HTML below is adapted from the spec's reference host
+ * (`github.com/modelcontextprotocol/ext-apps/examples/basic-host/` —
+ * sandbox.html + src/sandbox.ts + serve.ts), matching the pattern
+ * `@ggui-ai/agent-server`'s bundled sandbox proxy uses. CSP arrives as a
+ * `?csp=<urlencoded-json>` query param and is applied via HTTP HEADERS
+ * (tamper-proof — a `<meta>` CSP could be overridden by injected inline
+ * scripts), which is why this must be a real server, not a static file.
+ *
+ * # Deploying `web/`
+ *
+ * This plugin only runs under `vite` dev (`apply: "serve"`). A deployed
+ * build must point `VITE_SANDBOX_URL` at a hosted copy of this page on its
+ * own origin (see `.env.example`); without it the app falls back to a
+ * "UI resource received" notice instead of mounting UI same-origin.
+ */
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import type { Plugin } from "vite";
+
+/**
+ * The sandbox proxy's dev port. web/ runs on :6890; keep the `6891` literal
+ * in `src/App.tsx` (`DEV_SANDBOX_URL`) in sync — App.tsx cannot import this
+ * module (it would drag `node:http` into the browser bundle).
+ */
+export const SANDBOX_PROXY_PORT = 6891;
+
+/** CSP shape `<AppRenderer>` forwards on the sandbox URL's `?csp=` param. */
+interface McpUiResourceCsp {
+  readonly resourceDomains?: readonly string[];
+  readonly connectDomains?: readonly string[];
+  readonly frameDomains?: readonly string[];
+  readonly baseUriDomains?: readonly string[];
+}
+
+/** Drop CSP entries carrying directive-injection characters (`;`, newlines, quotes, spaces). */
+function sanitizeCspDomains(domains: readonly string[] | undefined): readonly string[] {
+  if (!domains) return [];
+  return domains.filter((d) => typeof d === "string" && !/[;\r\n'" ]/.test(d));
+}
+
+/** Build the CSP header value — mirrors the upstream basic-host `serve.ts`. */
+function buildCspHeader(csp: McpUiResourceCsp | undefined): string {
+  const resourceDomains = sanitizeCspDomains(csp?.resourceDomains).join(" ");
+  const connectDomains = sanitizeCspDomains(csp?.connectDomains).join(" ");
+  const frameDomains = sanitizeCspDomains(csp?.frameDomains).join(" ");
+  const baseUriDomains = sanitizeCspDomains(csp?.baseUriDomains).join(" ");
+  return [
+    "default-src 'self' 'unsafe-inline'",
+    `script-src 'self' 'unsafe-inline' 'unsafe-eval' blob: data: ${resourceDomains}`.trim(),
+    `style-src 'self' 'unsafe-inline' blob: data: ${resourceDomains}`.trim(),
+    `img-src 'self' data: blob: ${resourceDomains}`.trim(),
+    `font-src 'self' data: blob: ${resourceDomains}`.trim(),
+    `media-src 'self' data: blob: ${resourceDomains}`.trim(),
+    `connect-src 'self' ${connectDomains}`.trim(),
+    `worker-src 'self' blob: ${resourceDomains}`.trim(),
+    frameDomains.length > 0 ? `frame-src ${frameDomains}` : "frame-src 'none'",
+    "object-src 'none'",
+    baseUriDomains.length > 0 ? `base-uri ${baseUriDomains}` : "base-uri 'none'",
+  ].join("; ");
+}
+
+/**
+ * The self-contained sandbox.html. The inlined script:
+ *
+ *   1. Asserts iframe isolation (throws if it can reach `window.top`).
+ *   2. Creates an inner iframe sandboxed with `allow-scripts
+ *      allow-same-origin allow-forms`.
+ *   3. On `ui/notifications/sandbox-resource-ready` from the parent, writes
+ *      the app HTML into the inner iframe.
+ *   4. Relays every other postMessage bidirectionally, origin-checked.
+ *   5. Posts `ui/notifications/sandbox-proxy-ready` once attached.
+ */
+const SANDBOX_HTML = `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="color-scheme" content="light dark">
+    <title>sandbox proxy</title>
+    <style>
+      html, body { margin: 0; height: 100vh; height: 100dvh; width: 100%; background-color: transparent; }
+      body { display: flex; flex-direction: column; }
+      * { box-sizing: border-box; }
+      iframe {
+        background-color: transparent;
+        border: 0px none transparent;
+        padding: 0px;
+        overflow: hidden;
+        flex-grow: 1;
+        color-scheme: inherit;
+      }
+    </style>
+  </head>
+  <body>
+    <script>
+(function(){
+  'use strict';
+  if (window.self === window.top) {
+    throw new Error('This file is only to be used in an iframe sandbox.');
+  }
+  if (!document.referrer) {
+    throw new Error('No referrer, cannot validate embedding site.');
+  }
+  var EXPECTED_HOST_ORIGIN = new URL(document.referrer).origin;
+  var OWN_ORIGIN = new URL(window.location.href).origin;
+  // Security self-test: top access MUST throw (sandbox attribute strips same-origin).
+  try {
+    window.top.alert('If you see this, the sandbox is not setup securely.');
+    throw 'FAIL';
+  } catch (e) {
+    if (e === 'FAIL') {
+      throw new Error('The sandbox is not setup securely.');
+    }
+  }
+  // Inner iframe — the untrusted app HTML lands here.
+  var inner = document.createElement('iframe');
+  inner.style = 'width:100%; height:100%; border:none;';
+  inner.setAttribute('sandbox', 'allow-scripts allow-same-origin allow-forms');
+  document.body.appendChild(inner);
+  var RESOURCE_READY = 'ui/notifications/sandbox-resource-ready';
+  var PROXY_READY = 'ui/notifications/sandbox-proxy-ready';
+  window.addEventListener('message', function(event) {
+    if (event.source === window.parent) {
+      if (event.origin !== EXPECTED_HOST_ORIGIN) {
+        console.error('[Sandbox] Rejecting parent message from unexpected origin:', event.origin);
+        return;
+      }
+      if (event.data && event.data.method === RESOURCE_READY) {
+        var params = event.data.params || {};
+        var html = params.html;
+        var sandboxAttr = params.sandbox;
+        if (typeof sandboxAttr === 'string') {
+          inner.setAttribute('sandbox', sandboxAttr);
+        }
+        if (typeof html === 'string') {
+          var doc = inner.contentDocument || (inner.contentWindow && inner.contentWindow.document);
+          if (doc) {
+            doc.open();
+            doc.write(html);
+            doc.close();
+          } else {
+            inner.srcdoc = html;
+          }
+        }
+      } else {
+        if (inner && inner.contentWindow) {
+          inner.contentWindow.postMessage(event.data, '*');
+        }
+      }
+    } else if (event.source === inner.contentWindow) {
+      if (event.origin !== OWN_ORIGIN) {
+        console.error('[Sandbox] Rejecting inner message from unexpected origin:', event.origin);
+        return;
+      }
+      window.parent.postMessage(event.data, EXPECTED_HOST_ORIGIN);
+    }
+  });
+  window.parent.postMessage({
+    jsonrpc: '2.0',
+    method: PROXY_READY,
+    params: {},
+  }, EXPECTED_HOST_ORIGIN);
+})();
+    </script>
+  </body>
+</html>`;
+
+function handleRequest(req: IncomingMessage, res: ServerResponse): void {
+  const url = new URL(req.url ?? "/", "http://placeholder");
+  if (req.method === "GET" && (url.pathname === "/" || url.pathname === "/sandbox.html")) {
+    let csp: McpUiResourceCsp | undefined;
+    const cspParam = url.searchParams.get("csp");
+    if (cspParam !== null) {
+      try {
+        const parsed: unknown = JSON.parse(cspParam);
+        if (parsed !== null && typeof parsed === "object") {
+          csp = parsed as McpUiResourceCsp;
+        }
+      } catch {
+        // Malformed ?csp= — fall through to the default (self-only) header;
+        // an app loading external resources will surface a CSP violation in
+        // the console rather than silently widening the policy.
+      }
+    }
+    res.setHeader("Content-Security-Policy", buildCspHeader(csp));
+    res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.statusCode = 200;
+    res.end(SANDBOX_HTML);
+    return;
+  }
+  res.statusCode = 404;
+  res.setHeader("Content-Type", "text/plain; charset=utf-8");
+  res.end("sandbox proxy: only GET /sandbox.html is served here\n");
+}
+
+/**
+ * Vite plugin: boot the sandbox proxy alongside `vite` dev, tear it down
+ * with it. Dev-only (`apply: "serve"`); deployed builds set
+ * `VITE_SANDBOX_URL` instead.
+ */
+export function sandboxProxyPlugin(): Plugin {
+  let server: Server | undefined;
+  return {
+    name: "agentic-app-template:mcp-apps-sandbox-proxy",
+    apply: "serve",
+    configureServer(vite) {
+      server = createServer(handleRequest);
+      server.on("error", (err) => {
+        vite.config.logger.error(`[sandbox-proxy] ${String(err)}`);
+      });
+      server.listen(SANDBOX_PROXY_PORT, "127.0.0.1", () => {
+        vite.config.logger.info(
+          `  sandbox proxy: http://127.0.0.1:${SANDBOX_PROXY_PORT}/sandbox.html`
+        );
+      });
+      vite.httpServer?.on("close", () => {
+        server?.close();
+        server = undefined;
+      });
+    },
+  };
+}