@roxyon/mcp 0.1.2 → 0.3.0

package/dist/chunk-U6ILIHUR.js

@@ -0,0 +1,818 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { createRequire } from "module";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/prompts.ts
+import { z } from "zod";
+function registerPrompts(server) {
+  server.registerPrompt(
+    "scaffold-lumen-app",
+    {
+      title: "Scaffold a LumenJS + Roxyon app",
+      description: "Guidance for creating a new LumenJS SPA wired to the Roxyon BaaS and ready to deploy.",
+      argsSchema: {
+        idea: z.string().describe("What the app should do."),
+        dir: z.string().optional().describe("Where to create it.")
+      }
+    },
+    ({ idea, dir }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Build a LumenJS single-page app: ${idea}
+
+Steps:
+1. Read the "roxyon://docs/lumenjs" resource \u2014 follow V1 rules exactly (one bind per region, no nested bind, build option lists in JS not :for, check every BaaS write for an error field).
+2. Read "roxyon://docs/baas" for the data/auth API.
+3. Scaffold with the LumenJS CLI: \`lm create <name>\`${dir ? ` in ${dir}` : ""}. Put views under src/views/, wire the BaaS in src/index.js via config.json.
+4. When it runs locally (\`lm serve\`), call roxyon_init then roxyon_deploy (dry run first, then confirm:true).`
+          }
+        }
+      ]
+    })
+  );
+  server.registerPrompt(
+    "build-and-ship-site",
+    {
+      title: "Build a site and host it on Roxyon",
+      description: "Generate a static site (or no-build LumenJS SPA) in the conversation and publish it to a Roxyon host \u2014 for the hosted connector, no local files.",
+      argsSchema: {
+        brief: z.string().describe("What the site should be."),
+        host: z.string().describe("Where to host it, e.g. promo.mycompany.com")
+      }
+    },
+    ({ brief, host }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Build and publish a website to ${host}.
+
+Brief: ${brief}
+
+1. Read "roxyon://docs/recipe" and follow it. (Read "roxyon://docs/lumenjs" too only if the site needs reactivity.)
+2. If ${host} is not already on the account, roxyon_add_domain { host: "${host}", confirm: true } (add spa:true only for a real single-page app).
+3. Generate the site \u2014 self-contained static files, relative paths, real .html per page or <page>/index.html, \u226460 files / 2 MB.
+4. roxyon_deploy_content { host: "${host}", files: [...], clean: true, confirm: true } (dry-run first).
+5. roxyon_list_files { host: "${host}" } to verify, then give me the URL. Note that HTTPS may take a couple of minutes on a brand-new host.`
+          }
+        }
+      ]
+    })
+  );
+  server.registerPrompt(
+    "deploy-to-roxyon",
+    {
+      title: "Deploy this project to Roxyon",
+      description: "Walk through deploying the current project to Roxyon infrastructure.",
+      argsSchema: { dir: z.string().describe("Absolute path to the project.") }
+    },
+    ({ dir }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Deploy the project at ${dir} to Roxyon.
+
+1. If there is no roxyon.json, call roxyon_init (it detects the runtime; ask me which host if there are several).
+2. Call roxyon_deploy with just the dir first to see the plan.
+3. If the plan looks right, call roxyon_deploy again with confirm:true.
+4. For an app runtime, report the final status and, if it failed, the last error from roxyon_app_status.`
+          }
+        }
+      ]
+    })
+  );
+}
+
+// src/resources.ts
+import { readFile } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var RESOURCE_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "resources");
+var DOCS = [
+  {
+    uri: "roxyon://docs/lumenjs",
+    name: "lumenjs-reference",
+    file: "lumenjs.md",
+    title: "LumenJS \u2014 complete reference",
+    description: "Full LumenJS V1 reference for building SPAs with vanilla JS/HTML/CSS (no build step), contrasted with Vue/React. Read before writing .view files."
+  },
+  {
+    uri: "roxyon://docs/baas",
+    name: "baas-reference",
+    file: "baas.md",
+    title: "Roxyon BaaS reference",
+    description: "The Roxyon Backend-as-a-Service REST API: endpoints, auth flow, query rules, and the resolve-on-failure write behaviour."
+  },
+  {
+    uri: "roxyon://docs/deploy",
+    name: "deploy-reference",
+    file: "deploy.md",
+    title: "Deploying to Roxyon",
+    description: "How roxyon_init / roxyon_deploy work, the roxyon.json schema, static vs app deploys, env vars, and git push-to-deploy."
+  },
+  {
+    uri: "roxyon://docs/recipe",
+    name: "web-deploy-recipe",
+    file: "recipe-web-deploy.md",
+    title: "Recipe \u2014 build a site and host it",
+    description: 'The end-to-end flow for "build a landing page and put it on sub.mydomain.com" over the hosted connector: roxyon_add_domain \u2192 roxyon_deploy_content \u2192 roxyon_list_files.'
+  }
+];
+function registerResources(server) {
+  for (const doc of DOCS) {
+    server.registerResource(
+      doc.name,
+      doc.uri,
+      { title: doc.title, description: doc.description, mimeType: "text/markdown" },
+      async () => {
+        const body = await readFile(join(RESOURCE_DIR, doc.file), "utf8");
+        return { contents: [{ uri: doc.uri, mimeType: "text/markdown", text: body }] };
+      }
+    );
+  }
+}
+
+// src/tools.ts
+import { formatEnv } from "@roxyon/api-client";
+import {
+  buildIgnore,
+  buildProjectConfig,
+  deployProject,
+  detectRuntime,
+  listFiles,
+  loadProjectConfig,
+  packFiles,
+  saveProjectConfig
+} from "@roxyon/deploy-core";
+import { z as z2 } from "zod";
+
+// src/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var storage = new AsyncLocalStorage();
+function runWithContext(ctx, fn) {
+  return storage.run(ctx, fn);
+}
+function currentContext() {
+  return storage.getStore() ?? {};
+}
+
+// src/session.ts
+import { Roxyon, isAuthError } from "@roxyon/api-client";
+import { endpointsFromEnv, loadCredentials, tokenFromEnv } from "@roxyon/deploy-core";
+var NotAuthenticatedError = class extends Error {
+  constructor() {
+    super(
+      "Not signed in to Roxyon. Run `roxyon login` in a terminal, or set ROXYON_TOKEN in this MCP server's environment."
+    );
+    this.name = "NotAuthenticatedError";
+  }
+};
+async function getSession() {
+  const { apiUrl, consoleUrl } = endpointsFromEnv();
+  const requestToken = currentContext().token;
+  if (requestToken) {
+    return {
+      roxyon: new Roxyon({ sessionToken: requestToken, baseUrl: apiUrl, consoleUrl }),
+      source: "oauth"
+    };
+  }
+  const envToken = tokenFromEnv();
+  if (envToken) {
+    return {
+      roxyon: new Roxyon({ sessionToken: envToken, baseUrl: apiUrl, consoleUrl }),
+      source: "env-token"
+    };
+  }
+  const creds = await loadCredentials();
+  if (!creds?.sessionToken) throw new NotAuthenticatedError();
+  return {
+    roxyon: new Roxyon({ sessionToken: creds.sessionToken, baseUrl: apiUrl, consoleUrl }),
+    preferredSubscription: creds.subscription,
+    source: "stored-login"
+  };
+}
+function isSessionGone(err) {
+  return err instanceof NotAuthenticatedError || isAuthError(err);
+}
+
+// src/result.ts
+function text(body, structured) {
+  return {
+    content: [{ type: "text", text: body }],
+    ...structured ? { structuredContent: structured } : {}
+  };
+}
+function errorResult(message, structured) {
+  return {
+    content: [{ type: "text", text: message }],
+    ...structured ? { structuredContent: structured } : {},
+    isError: true
+  };
+}
+async function guard(fn) {
+  try {
+    return await fn();
+  } catch (err) {
+    if (isSessionGone(err)) {
+      return errorResult(
+        err.message || "Roxyon session expired \u2014 run `roxyon login` again, or refresh ROXYON_TOKEN."
+      );
+    }
+    return errorResult(err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/tools.ts
+var MAX_FILES = 60;
+var MAX_FILE_BYTES = 1024 * 1024;
+var MAX_TOTAL_BYTES = 2 * 1024 * 1024;
+function remoteFilesystemBlock(tool) {
+  if (!currentContext().remote) return null;
+  return errorResult(
+    [
+      `${tool} needs access to your local project files, which the hosted Roxyon MCP`,
+      "server does not have. Either:",
+      "  \u2022 run the `roxyon` CLI locally (`npm i -g @roxyon/cli`, then `roxyon deploy`), or",
+      "  \u2022 use `roxyon_link_github` to connect a git repo for push-to-deploy, then",
+      "    `roxyon_app_status` / `roxyon_logs` to watch it here."
+    ].join("\n")
+  );
+}
+async function resolveApp(args) {
+  if (args.application) return { applicationId: args.application };
+  if (args.dir) {
+    const cfg = await loadProjectConfig(args.dir);
+    if (cfg?.application) return { applicationId: cfg.application, host: cfg.host };
+    throw new Error(
+      `No application linked in ${args.dir}/roxyon.json. Deploy it once (roxyon_deploy) or pass "application".`
+    );
+  }
+  throw new Error('Pass either "application" (an id) or "dir" (a project directory).');
+}
+function accountContext(session) {
+  return session.roxyon.account.context();
+}
+function registerTools(server) {
+  server.registerTool(
+    "roxyon_whoami",
+    {
+      title: "Roxyon: who am I",
+      description: "Show the signed-in Roxyon user and their subscriptions (which one is active).",
+      inputSchema: {}
+    },
+    () => guard(async () => {
+      const session = await getSession();
+      const ctx = await accountContext(session);
+      const lines = [
+        `User: ${ctx.user.email || ctx.user.id} (${ctx.user.id})`,
+        `Auth: ${session.source}${ctx.scopes.length ? ` (scopes: ${ctx.scopes.join(", ")})` : ""}`,
+        "",
+        "Subscriptions:",
+        ...ctx.subscriptions.map((s) => `  ${s.name || s.id} \u2014 ${s.status || "?"}`),
+        "",
+        `Hosts: ${ctx.domains.map((d) => d.name).join(", ") || "(none)"}`
+      ];
+      return text(lines.join("\n"), {
+        user: ctx.user,
+        scopes: ctx.scopes,
+        subscriptions: ctx.subscriptions,
+        hosts: ctx.domains.map((d) => d.name)
+      });
+    })
+  );
+  server.registerTool(
+    "roxyon_list_domains",
+    {
+      title: "Roxyon: list hosts",
+      description: "List the domains (hosts) on the active subscription \u2014 the possible deploy targets.",
+      inputSchema: {}
+    },
+    () => guard(async () => {
+      const session = await getSession();
+      const { domains } = await accountContext(session);
+      return text(
+        domains.length ? domains.map(
+          (d) => `- ${d.name}${d.status && d.status !== "active" ? ` (${d.status})` : ""}`
+        ).join("\n") : "(no hosts on this account)",
+        { hosts: domains }
+      );
+    })
+  );
+  server.registerTool(
+    "roxyon_list_apps",
+    {
+      title: "Roxyon: list applications",
+      description: "List the applications on the active subscription with their status and revision.",
+      inputSchema: {}
+    },
+    () => guard(async () => {
+      const session = await getSession();
+      const apps = await session.roxyon.account.apps();
+      const body = apps.length ? apps.map(
+        (a) => `- ${a.name} [${a.id}] \u2014 ${a.status || "?"} (rev ${a.appliedRevision}/${a.configRevision})${a.repo ? ` \xB7 git:${a.repo.branch}` : ""}`
+      ).join("\n") : "(no applications)";
+      return text(body, { applications: apps });
+    })
+  );
+  server.registerTool(
+    "roxyon_init",
+    {
+      title: "Roxyon: initialise a project",
+      description: "Detect a project's type and write roxyon.json. Run this once per project before roxyon_deploy. Does not create anything on the platform.",
+      inputSchema: {
+        dir: z2.string().describe("Absolute path to the project directory."),
+        runtime: z2.enum(["lumen", "node", "python", "php"]).optional(),
+        host: z2.string().optional().describe("Deploy host (a domain on the subscription)."),
+        folder: z2.string().optional().describe('Sub-path under the host; "" = site root.'),
+        overwrite: z2.boolean().optional().describe("Replace an existing roxyon.json.")
+      }
+    },
+    (args) => guard(async () => {
+      const blocked = remoteFilesystemBlock("roxyon_init");
+      if (blocked) return blocked;
+      const session = await getSession();
+      const existing = await loadProjectConfig(args.dir);
+      if (existing && !args.overwrite) {
+        return errorResult(
+          `roxyon.json already exists in ${args.dir}. Pass overwrite:true to replace it.`,
+          { config: existing }
+        );
+      }
+      const { domains } = await accountContext(session);
+      if (domains.length === 0) {
+        return errorResult(
+          "This account has no hosts. Add a domain in the Roxyon console first."
+        );
+      }
+      const detected = await detectRuntime(args.dir);
+      const runtime = args.runtime ?? detected.runtime;
+      const host = args.host ?? domains[0].name;
+      if (!domains.some((d) => d.name === host)) {
+        return errorResult(
+          `Host "${host}" is not on this account (have: ${domains.map((d) => d.name).join(", ")}).`
+        );
+      }
+      const config = buildProjectConfig({
+        cwd: args.dir,
+        runtime,
+        host,
+        folder: args.folder,
+        start: detected.start
+      });
+      const path = await saveProjectConfig(config, args.dir);
+      return text(
+        `Wrote ${path}
+Detected: ${detected.runtime} (${detected.reason})
+
+${JSON.stringify(config, null, 2)}`,
+        { path, detected: detected.runtime, config }
+      );
+    })
+  );
+  server.registerTool(
+    "roxyon_deploy",
+    {
+      title: "Roxyon: deploy a project",
+      description: 'Build (if configured) and deploy the project in "dir" to Roxyon. Without confirm:true this returns a dry-run plan (what would build, where it would go, how many files). With confirm:true it runs the build, uploads, and \u2014 for app runtimes \u2014 waits for it to go live. Requires roxyon.json (run roxyon_init first).',
+      inputSchema: {
+        dir: z2.string().describe("Absolute path to the project directory (must contain roxyon.json)."),
+        confirm: z2.boolean().optional().describe("Actually deploy. Omit for a dry-run plan."),
+        build: z2.boolean().optional().describe("Run the configured build command (default true)."),
+        follow: z2.boolean().optional().describe("For app runtimes, wait until running/failed (default true).")
+      }
+    },
+    (args) => guard(async () => {
+      const blocked = remoteFilesystemBlock("roxyon_deploy");
+      if (blocked) return blocked;
+      const session = await getSession();
+      const config = await loadProjectConfig(args.dir);
+      if (!config) {
+        return errorResult(`No roxyon.json in ${args.dir}. Run roxyon_init first.`);
+      }
+      if (!args.confirm) {
+        const ig = await buildIgnore(args.dir);
+        const packRoot = config.kind === "static" && config.outDir ? `${args.dir}/${config.outDir}` : args.dir;
+        let files = [];
+        try {
+          files = await listFiles(packRoot, ig);
+        } catch {
+        }
+        const plan = [
+          "DRY RUN \u2014 pass confirm:true to deploy.",
+          "",
+          `Project:  ${config.name} (${config.runtime}, ${config.kind})`,
+          `Target:   ${config.host}${config.folder ? `/${config.folder}` : ""}`,
+          config.build ? `Build:    ${config.build}` : "Build:    (none)",
+          config.kind === "app" ? `App:      ${config.application ?? "(created on first deploy)"}` : "Serve:    static files from the host document root",
+          files.length ? `Would pack ${files.length} file(s) from ${config.kind === "static" && config.outDir ? config.outDir : "."}` : `Would pack the build output (${config.outDir ?? "dist"}) after building`
+        ].join("\n");
+        return text(plan, { dryRun: true, config });
+      }
+      const logLines = [];
+      const outcome = await deployProject({
+        cwd: args.dir,
+        roxyon: session.roxyon,
+        preferredSubscription: session.preferredSubscription,
+        build: args.build,
+        follow: args.follow ?? true,
+        timeoutMs: 5 * 60 * 1e3,
+        reporter: {
+          step: (m) => logLines.push(`\xBB ${m}`),
+          log: (l) => logLines.push(`  ${l}`)
+        }
+      });
+      const tail = logLines.slice(-60).join("\n");
+      if (outcome.kind === "static" && outcome.ok) {
+        return text(`${tail}
+
+\u2713 Live: ${outcome.url} (${outcome.files} files)`, {
+          ok: true,
+          kind: "static",
+          url: outcome.url
+        });
+      }
+      if (outcome.kind === "app" && outcome.ok) {
+        return text(
+          `${tail}
+
+\u2713 ${outcome.status === "running" ? `Live: ${outcome.url ?? outcome.application}` : `Build queued (revision ${outcome.revision})`}`,
+          {
+            ok: true,
+            kind: "app",
+            application: outcome.application,
+            status: outcome.status,
+            url: outcome.url
+          }
+        );
+      }
+      return errorResult(
+        `${tail}
+
+\u2717 Deploy failed: ${"error" in outcome ? outcome.error : "unknown"}`,
+        { ok: false, application: "application" in outcome ? outcome.application : void 0 }
+      );
+    })
+  );
+  server.registerTool(
+    "roxyon_app_status",
+    {
+      title: "Roxyon: application status",
+      description: "Current status, revisions and last error for an application (by id or project dir).",
+      inputSchema: {
+        application: z2.string().optional(),
+        dir: z2.string().optional().describe("A project directory whose roxyon.json links an application.")
+      }
+    },
+    (args) => guard(async () => {
+      const session = await getSession();
+      const { applicationId } = await resolveApp(args);
+      const app = await session.roxyon.account.getApp(applicationId);
+      if (!app) return errorResult(`Application ${applicationId} not found.`);
+      const settled = app.configRevision <= app.appliedRevision;
+      const body = [
+        `${app.name} [${app.id}]`,
+        `Status:   ${app.status || "?"}${settled ? "" : " (applying)"}`,
+        `Revision: ${app.appliedRevision} / ${app.configRevision}`,
+        `Runtime:  ${app.runtime}`.trim(),
+        app.lastError ? `
+Last error:
+${app.lastError}` : ""
+      ].filter(Boolean).join("\n");
+      return text(body, {
+        id: app.id,
+        status: app.status,
+        settled,
+        configRevision: app.configRevision,
+        appliedRevision: app.appliedRevision,
+        lastError: app.lastError || void 0
+      });
+    })
+  );
+  server.registerTool(
+    "roxyon_logs",
+    {
+      title: "Roxyon: application logs",
+      description: "Recent journal lines for an application (by id or project dir).",
+      inputSchema: {
+        application: z2.string().optional(),
+        dir: z2.string().optional(),
+        lines: z2.number().int().min(1).max(1e3).optional().describe("How many lines (default 100).")
+      }
+    },
+    (args) => guard(async () => {
+      const session = await getSession();
+      const { applicationId } = await resolveApp(args);
+      const lines = await session.roxyon.applications.logs(applicationId, args.lines ?? 100);
+      return text(lines.join("\n") || "(no log lines)", { lines });
+    })
+  );
+  server.registerTool(
+    "roxyon_restart",
+    {
+      title: "Roxyon: restart an application",
+      description: "Bounce the application process (no rebuild). Needs confirm:true.",
+      inputSchema: {
+        application: z2.string().optional(),
+        dir: z2.string().optional(),
+        confirm: z2.boolean().optional()
+      }
+    },
+    (args) => guard(async () => {
+      const session = await getSession();
+      const { applicationId } = await resolveApp(args);
+      if (!args.confirm)
+        return text(`Would restart ${applicationId}. Pass confirm:true.`, { dryRun: true });
+      await session.roxyon.applications.restart(applicationId);
+      return text(`Restart queued for ${applicationId}.`, { ok: true });
+    })
+  );
+  server.registerTool(
+    "roxyon_env_get",
+    {
+      title: "Roxyon: read environment variables",
+      description: "An application's environment variables as KEY=value lines.",
+      inputSchema: { application: z2.string().optional(), dir: z2.string().optional() }
+    },
+    (args) => guard(async () => {
+      const session = await getSession();
+      const { applicationId } = await resolveApp(args);
+      const env = await session.roxyon.applications.getEnv(applicationId);
+      return text(formatEnv(env) || "(none set)", { env });
+    })
+  );
+  server.registerTool(
+    "roxyon_env_set",
+    {
+      title: "Roxyon: set environment variables",
+      description: "Merge variables into an application's environment and bump its revision. Run roxyon_deploy afterwards to apply. Needs confirm:true. PORT and HOST are platform-managed and ignored.",
+      inputSchema: {
+        application: z2.string().optional(),
+        dir: z2.string().optional(),
+        vars: z2.record(z2.string()).describe('{ KEY: "value", ... } to set.'),
+        remove: z2.array(z2.string()).optional().describe("Keys to delete."),
+        confirm: z2.boolean().optional()
+      }
+    },
+    (args) => guard(async () => {
+      const session = await getSession();
+      const { applicationId } = await resolveApp(args);
+      const set = {};
+      for (const [k, v] of Object.entries(args.vars)) {
+        if (k === "PORT" || k === "HOST") continue;
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(k)) return errorResult(`Invalid env key "${k}".`);
+        set[k] = v;
+      }
+      const planned = [...Object.keys(set), ...(args.remove ?? []).map((k) => `-${k}`)];
+      if (!args.confirm) {
+        return text(`Would update: ${planned.join(", ") || "(nothing)"}. Pass confirm:true.`, {
+          dryRun: true,
+          changed: planned
+        });
+      }
+      const r = await session.roxyon.applications.setEnv(applicationId, {
+        set,
+        remove: args.remove ?? []
+      });
+      return text(`Updated ${r.changed.join(", ") || "(nothing)"}. Run roxyon_deploy to apply.`, {
+        ok: true,
+        changed: r.changed
+      });
+    })
+  );
+  server.registerTool(
+    "roxyon_link_github",
+    {
+      title: "Roxyon: connect a git remote",
+      description: "Connect a git repository to an application for push-to-deploy. Returns the deploy key and webhook URL to add to the repo. Needs confirm:true.",
+      inputSchema: {
+        application: z2.string().optional(),
+        dir: z2.string().optional(),
+        repoUrl: z2.string().describe("SSH git URL, e.g. git@github.com:you/app.git"),
+        branch: z2.string().optional().describe("Branch to deploy (default main)."),
+        confirm: z2.boolean().optional()
+      }
+    },
+    (args) => guard(async () => {
+      const session = await getSession();
+      const { applicationId } = await resolveApp(args);
+      if (!args.confirm) {
+        return text(
+          `Would connect ${args.repoUrl} (${args.branch ?? "main"}) to ${applicationId}. Pass confirm:true.`,
+          { dryRun: true }
+        );
+      }
+      const res = await session.roxyon.applications.repoConnect(
+        applicationId,
+        args.repoUrl,
+        args.branch ?? "main"
+      );
+      const body = [
+        `Connected ${args.repoUrl} (${args.branch ?? "main"}).`,
+        res.deployKey ? `
+Deploy key (add to the repo, read-only):
+${res.deployKey}` : "",
+        res.webhookUrl ? `
+Webhook URL: ${res.webhookUrl}` : "",
+        res.secret ? `Webhook secret: ${res.secret}` : "",
+        res.hint ? `
+${res.hint}` : ""
+      ].filter(Boolean).join("\n");
+      return text(body, {
+        ok: true,
+        deployKey: res.deployKey,
+        webhookUrl: res.webhookUrl,
+        secret: res.secret
+      });
+    })
+  );
+  server.registerTool(
+    "roxyon_add_domain",
+    {
+      title: "Roxyon: add a subdomain / host",
+      description: "Provision a host \u2014 DNS + web server + automatic HTTPS. The host must be a subdomain of a domain the account already hosts (or a *.roxyon.com subdomain). Returns while it is still coming up; TLS follows a minute or two later. Needs confirm:true.",
+      inputSchema: {
+        host: z2.string().describe("The full hostname, e.g. promo.mycompany.com"),
+        subscription: z2.string().optional().describe("Which subscription to attach it to (omit if the account has one)."),
+        spa: z2.boolean().optional().describe("Single-page app: unmatched paths serve /index.html."),
+        confirm: z2.boolean().optional()
+      }
+    },
+    (args) => guard(async () => {
+      const session = await getSession();
+      if (!args.confirm) {
+        return text(
+          `Would provision ${args.host}${args.spa ? " (SPA routing)" : ""}. Pass confirm:true.`,
+          { dryRun: true }
+        );
+      }
+      const res = await session.roxyon.domains.create({
+        host: args.host,
+        subscription: args.subscription ?? session.preferredSubscription,
+        siteType: args.spa ? "spa" : void 0
+      });
+      const live = res.status === "active";
+      return text(
+        [
+          `${res.host} \u2014 ${res.type}, ${res.status}.`,
+          live ? "The host is up. HTTPS may take another minute to issue." : "DNS + web server are being set up (~1\u20132 min), then HTTPS. Check roxyon_list_domains, or just deploy now \u2014 files are kept and served once it is live."
+        ].join("\n"),
+        { ok: true, host: res.host, type: res.type, status: res.status }
+      );
+    })
+  );
+  server.registerTool(
+    "roxyon_deploy_content",
+    {
+      title: "Roxyon: deploy generated files",
+      description: [
+        "Publish a set of files you generated (HTML/CSS/JS/assets) to a host on the account.",
+        "The host must already exist (roxyon_add_domain, or an existing site). Overlay by",
+        "default \u2014 pass clean:true to replace the whole document root. Needs confirm:true.",
+        `Limits: ${MAX_FILES} files, ${MAX_FILE_BYTES / 1024 | 0} KB per file,`,
+        `${(MAX_TOTAL_BYTES / 1024 / 1024).toFixed(1)} MB total (base64-encode binaries).`
+      ].join(" "),
+      inputSchema: {
+        host: z2.string().describe("Target host, e.g. promo.mycompany.com"),
+        folder: z2.string().optional().describe('Sub-path under the host; "" = site root.'),
+        files: z2.array(
+          z2.object({
+            path: z2.string().describe("Relative path, e.g. index.html, about/index.html"),
+            content: z2.string(),
+            encoding: z2.enum(["utf8", "base64"]).optional()
+          })
+        ).min(1),
+        clean: z2.boolean().optional().describe("Replace the whole docroot (keeps .well-known)."),
+        spa: z2.boolean().optional().describe("Also flip the host to SPA routing."),
+        confirm: z2.boolean().optional()
+      }
+    },
+    (args) => guard(async () => {
+      const session = await getSession();
+      if (args.files.length > MAX_FILES) {
+        return errorResult(`Too many files (${args.files.length}); the limit is ${MAX_FILES}.`);
+      }
+      let total = 0;
+      for (const f of args.files) {
+        const n = Buffer.byteLength(f.content, f.encoding === "base64" ? "base64" : "utf8");
+        if (n > MAX_FILE_BYTES) {
+          return errorResult(
+            `"${f.path}" is ${n / 1024 | 0} KB; the per-file limit is ${MAX_FILE_BYTES / 1024 | 0} KB.`
+          );
+        }
+        total += n;
+      }
+      if (total > MAX_TOTAL_BYTES) {
+        return errorResult(
+          `Total content is ${(total / 1024 / 1024).toFixed(1)} MB; the limit is ${(MAX_TOTAL_BYTES / 1024 / 1024).toFixed(1)} MB. Deploy in parts or use the CLI.`
+        );
+      }
+      const folder = args.folder ?? "";
+      if (!args.confirm) {
+        return text(
+          [
+            "DRY RUN \u2014 pass confirm:true to deploy.",
+            "",
+            `Host:   ${args.host}${folder ? `/${folder}` : ""}`,
+            `Files:  ${args.files.length} (${total / 1024 | 0} KB)`,
+            `Mode:   ${args.clean ? "clean (replaces the document root)" : "overlay"}${args.spa ? " + SPA routing" : ""}`,
+            ...args.files.slice(0, 20).map((f) => `  ${f.path}`),
+            args.files.length > 20 ? `  \u2026 ${args.files.length - 20} more` : ""
+          ].filter(Boolean).join("\n"),
+          { dryRun: true }
+        );
+      }
+      const { buffer, files } = await packFiles(args.files, { maxBytes: MAX_TOTAL_BYTES });
+      const r = await session.roxyon.sites.deploy(args.host, folder, buffer, {
+        clean: args.clean,
+        spa: args.spa
+      });
+      const size = r.bytes ? ` (${r.bytes / 1024 | 0} KB)` : "";
+      const spaNote = args.spa ? "\nSPA routing enabled \u2014 deep links resolve to index.html." : "";
+      return text(
+        `\u2713 Deployed ${files.length} file(s) to https://${args.host}${folder ? `/${folder}` : ""}${size}.${spaNote}`,
+        { ok: true, host: args.host, files: files.length }
+      );
+    })
+  );
+  server.registerTool(
+    "roxyon_list_files",
+    {
+      title: "Roxyon: list a site\u2019s files",
+      description: "The files currently deployed to a host's document root.",
+      inputSchema: {
+        host: z2.string(),
+        folder: z2.string().optional(),
+        path: z2.string().optional().describe("List under this sub-path only.")
+      }
+    },
+    (args) => guard(async () => {
+      const session = await getSession();
+      const files = await session.roxyon.sites.listFiles(
+        args.host,
+        args.folder ?? "",
+        args.path ?? ""
+      );
+      const body = files.length ? files.map(
+        (f) => `${f.type === "dir" ? "d" : "-"} ${String(f.size).padStart(8)}  ${f.path}`
+      ).join("\n") : "(empty)";
+      return text(body, { files });
+    })
+  );
+  server.registerTool(
+    "roxyon_read_file",
+    {
+      title: "Roxyon: read a site file",
+      description: "Read one file from a host's document root (to review or edit it).",
+      inputSchema: {
+        host: z2.string(),
+        folder: z2.string().optional(),
+        path: z2.string().describe("Relative path, e.g. index.html")
+      }
+    },
+    (args) => guard(async () => {
+      const session = await getSession();
+      const f = await session.roxyon.sites.readFile(args.host, args.folder ?? "", args.path);
+      if (f.encoding === "base64") {
+        return text(
+          `${f.path} \u2014 ${f.size} bytes, binary (base64):
+
+${f.content.slice(0, 4096)}`,
+          { path: f.path, size: f.size, encoding: "base64" }
+        );
+      }
+      return text(f.content, { path: f.path, size: f.size, encoding: "utf8" });
+    })
+  );
+}
+
+// src/server.ts
+var SERVER_NAME = "roxyon";
+var SERVER_VERSION = createRequire(import.meta.url)("../package.json").version;
+function createServer() {
+  const server = new McpServer(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    {
+      instructions: "Roxyon lets you build LumenJS SPAs, use the Roxyon BaaS, and deploy apps and web projects to Roxyon infrastructure. Read the roxyon://docs/* resources before writing LumenJS or calling the BaaS. To deploy: roxyon_init once per project, then roxyon_deploy (dry run, then confirm:true). Side-effecting tools require confirm:true."
+    }
+  );
+  registerResources(server);
+  registerPrompts(server);
+  registerTools(server);
+  return server;
+}
+
+export {
+  runWithContext,
+  SERVER_NAME,
+  SERVER_VERSION,
+  createServer
+};
+//# sourceMappingURL=chunk-U6ILIHUR.js.map