@sakupa/mcp 0.1.0

package/dist/bin.js

@@ -0,0 +1,1866 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../core/dist/domain/constants.js
+var SERVICE_DOMAIN = "sakupa.com";
+var DEFAULT_API_BASE_URL = "https://api.sakupa.com";
+var FREE_SITE_URL_SUFFIX = `.${SERVICE_DOMAIN}`;
+var FREE_SITE_TTL_HOURS = 24;
+var FREE_SITE_MAX_TOTAL_BYTES = 10 * 1024 * 1024;
+var PAID_SITE_MAX_TOTAL_BYTES = 2 * 1024 * 1024 * 1024;
+var MAX_FILE_COUNT = 5e3;
+var MAX_SINGLE_FILE_BYTES = 25 * 1024 * 1024;
+var FREE_REQUESTS_PER_MINUTE = 240;
+var LOAD_BUDGET_ADVISORY = {
+  maxFiles: 50,
+  maxTotalBytes: 5 * 1024 * 1024,
+  minLoadsPerMinute: 8
+};
+var ALLOWED_STATIC_EXTENSIONS = {
+  html: "text/html; charset=utf-8",
+  htm: "text/html; charset=utf-8",
+  css: "text/css; charset=utf-8",
+  js: "text/javascript; charset=utf-8",
+  mjs: "text/javascript; charset=utf-8",
+  json: "application/json",
+  map: "application/json",
+  txt: "text/plain; charset=utf-8",
+  xml: "application/xml",
+  webmanifest: "application/manifest+json",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  avif: "image/avif",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf"
+};
+var FORBIDDEN_EXTENSIONS = [
+  "zip",
+  "tar",
+  "gz",
+  "tgz",
+  "bz2",
+  "xz",
+  "7z",
+  "rar",
+  "mp4",
+  "mov",
+  "avi",
+  "webm",
+  "mkv",
+  "m4v",
+  "mp3",
+  "wav",
+  "ogg",
+  "flac",
+  "aac",
+  "m4a",
+  "pdf",
+  "exe",
+  "dll",
+  "so",
+  "dylib",
+  "msi",
+  "dmg",
+  "pkg",
+  "deb",
+  "rpm",
+  "bin",
+  "sh",
+  "bash",
+  "zsh",
+  "bat",
+  "cmd",
+  "ps1",
+  "php",
+  "py",
+  "rb",
+  "pl",
+  "jar",
+  "war",
+  "sqlite",
+  "db",
+  "pem",
+  "key",
+  "p12",
+  "pfx",
+  "crt",
+  "csr",
+  "env"
+];
+var FORBIDDEN_FILE_NAMES = [
+  ".env",
+  ".envrc",
+  ".npmrc",
+  ".netrc",
+  "id_rsa",
+  "id_dsa",
+  "id_ecdsa",
+  "id_ed25519",
+  "credentials",
+  "credentials.json",
+  "serviceaccount.json",
+  "service-account.json",
+  ".htpasswd"
+];
+var FORBIDDEN_PATH_SEGMENTS = [
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  ".npm",
+  ".yarn",
+  ".pnpm-store",
+  "__macosx",
+  ".sakupa",
+  ".aws",
+  ".ssh"
+];
+var ALLOWED_HIDDEN_PATHS = [".well-known/"];
+
+// ../core/dist/domain/errors.js
+var HTTP_STATUS = {
+  invalid_request: 400,
+  validation_failed: 422,
+  unauthorized: 401,
+  forbidden: 403,
+  not_found: 404,
+  conflict: 409,
+  state_conflict: 409,
+  rate_limited: 429,
+  insufficient_balance: 402,
+  payment_required: 402,
+  confirmation_required: 428,
+  dns_not_verified: 403,
+  not_deployable: 422,
+  internal: 500
+};
+var SakupaError = class extends Error {
+  code;
+  httpStatus;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "SakupaError";
+    this.code = code;
+    this.httpStatus = HTTP_STATUS[code];
+    this.details = details;
+  }
+};
+function isSakupaError(err) {
+  return err instanceof SakupaError;
+}
+
+// ../core/dist/domain/tiers.js
+var GB = 1024 * 1024 * 1024;
+var MB = 1024 * 1024;
+var TIER_ORDER = ["water", "personal", "share", "business"];
+var TIERS = {
+  water: {
+    id: "water",
+    displayName: "Water",
+    priceJpy: 200,
+    storageBytes: 100 * MB,
+    transferBytes: 2 * GB,
+    requests: 2e4
+  },
+  personal: {
+    id: "personal",
+    displayName: "Personal",
+    priceJpy: 500,
+    storageBytes: 300 * MB,
+    transferBytes: 8 * GB,
+    requests: 1e5
+  },
+  share: {
+    id: "share",
+    displayName: "Share",
+    priceJpy: 1e3,
+    storageBytes: 1 * GB,
+    transferBytes: 20 * GB,
+    requests: 3e5
+  },
+  business: {
+    id: "business",
+    displayName: "Business",
+    priceJpy: 2e3,
+    storageBytes: 2 * GB,
+    transferBytes: 50 * GB,
+    requests: 8e5
+  }
+};
+function tierPriceJpy(id) {
+  return TIERS[id].priceJpy;
+}
+
+// ../core/dist/domain/manifest.js
+var PRIVATE_KEY_MARKER = /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----/;
+var TEXT_SNIFF_EXTENSIONS = /* @__PURE__ */ new Set(["html", "htm", "js", "mjs", "css", "json", "txt", "xml"]);
+function fileExtension(path) {
+  const base = path.split("/").pop() ?? "";
+  const idx = base.lastIndexOf(".");
+  if (idx <= 0)
+    return "";
+  return base.slice(idx + 1).toLowerCase();
+}
+function isPathSafe(path) {
+  if (path.length === 0 || path.length > 1024)
+    return false;
+  if (path.startsWith("/") || path.includes("\\") || path.includes("\0"))
+    return false;
+  const segments = path.split("/");
+  for (const seg of segments) {
+    if (seg === "" || seg === "." || seg === "..")
+      return false;
+  }
+  return true;
+}
+function isAllowedHidden(path) {
+  return ALLOWED_HIDDEN_PATHS.some((prefix) => path === prefix || path.startsWith(prefix));
+}
+function hasHiddenSegment(path) {
+  return path.split("/").some((seg) => seg.startsWith(".") && seg.length > 1);
+}
+function extractHtmlLang(html) {
+  const m = /<html[^>]*\slang\s*=\s*["']?([A-Za-z-]+)["']?/i.exec(html);
+  return m?.[1] ?? null;
+}
+function normalizeSupportedLang(lang) {
+  if (!lang)
+    return null;
+  const lower = lang.toLowerCase();
+  if (lower === "en" || lower.startsWith("en-"))
+    return "en";
+  if (lower === "ja" || lower.startsWith("ja-"))
+    return "ja";
+  if (lower === "zh-cn" || lower === "zh" || lower === "zh-hans")
+    return "zh-CN";
+  return null;
+}
+function validateDeployableFiles(files, opts) {
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  let totalBytes = 0;
+  if (files.length === 0) {
+    issues.push({ severity: "error", code: "empty_upload", message: "No files to deploy." });
+  }
+  if (files.length > MAX_FILE_COUNT) {
+    issues.push({
+      severity: "error",
+      code: "too_many_files",
+      message: `Too many files (${files.length} > ${MAX_FILE_COUNT}).`
+    });
+  }
+  const htmlPaths = [];
+  for (const file of files) {
+    const { path, size } = file;
+    if (!isPathSafe(path)) {
+      issues.push({
+        severity: "error",
+        code: "unsafe_path",
+        path,
+        message: `Unsafe file path: ${path}`
+      });
+      continue;
+    }
+    if (seen.has(path)) {
+      issues.push({
+        severity: "error",
+        code: "duplicate_path",
+        path,
+        message: `Duplicate file path: ${path}`
+      });
+      continue;
+    }
+    seen.add(path);
+    totalBytes += size;
+    const segments = path.split("/");
+    const base = (segments[segments.length - 1] ?? "").toLowerCase();
+    const ext = fileExtension(path);
+    const forbiddenSegment = segments.find((seg) => FORBIDDEN_PATH_SEGMENTS.includes(seg.toLowerCase()));
+    if (forbiddenSegment) {
+      issues.push({
+        severity: "error",
+        code: "forbidden_directory",
+        path,
+        message: `Directory "${forbiddenSegment}" cannot be deployed. Deploy only the built static output.`
+      });
+      continue;
+    }
+    if (FORBIDDEN_FILE_NAMES.includes(base) || base.startsWith(".env")) {
+      issues.push({
+        severity: "error",
+        code: "forbidden_file_name",
+        path,
+        message: `File "${base}" looks like a secret or configuration file and is never deployable.`
+      });
+      continue;
+    }
+    if (hasHiddenSegment(path) && !isAllowedHidden(path)) {
+      issues.push({
+        severity: "error",
+        code: "hidden_file",
+        path,
+        message: `Hidden file "${path}" is not deployable (only .well-known/ is allowed).`
+      });
+      continue;
+    }
+    if (FORBIDDEN_EXTENSIONS.includes(ext)) {
+      issues.push({
+        severity: "error",
+        code: "forbidden_extension",
+        path,
+        message: `File type ".${ext}" is not allowed (archives, media, executables, server code and secrets are rejected).`
+      });
+      continue;
+    }
+    if (!(ext in ALLOWED_STATIC_EXTENSIONS)) {
+      issues.push({
+        severity: "error",
+        code: "unknown_extension",
+        path,
+        message: `File type ".${ext || "(none)"}" is not in the static whitelist.`
+      });
+      continue;
+    }
+    if (size > MAX_SINGLE_FILE_BYTES) {
+      issues.push({
+        severity: "error",
+        code: "file_too_large",
+        path,
+        message: `File exceeds the ${Math.floor(MAX_SINGLE_FILE_BYTES / (1024 * 1024))}MB single-file limit.`
+      });
+    }
+    if (file.content && TEXT_SNIFF_EXTENSIONS.has(ext)) {
+      const text2 = safeDecode(file.content);
+      if (text2 && PRIVATE_KEY_MARKER.test(text2)) {
+        issues.push({
+          severity: "error",
+          code: "private_key_content",
+          path,
+          message: `File contains a private key block and is never deployable.`
+        });
+      }
+    }
+    if (ext === "html" || ext === "htm")
+      htmlPaths.push(path);
+  }
+  const maxTotal = opts.mode === "free" ? FREE_SITE_MAX_TOTAL_BYTES : PAID_SITE_MAX_TOTAL_BYTES;
+  if (totalBytes > maxTotal) {
+    issues.push({
+      severity: "error",
+      code: "total_too_large",
+      message: `Total size ${(totalBytes / (1024 * 1024)).toFixed(1)}MB exceeds the ${Math.floor(maxTotal / (1024 * 1024))}MB ${opts.mode} limit.`
+    });
+  }
+  if (opts.mode === "free" && files.length > 0) {
+    const loadsPerMinute = Math.max(1, Math.floor(FREE_REQUESTS_PER_MINUTE / files.length));
+    if (files.length > LOAD_BUDGET_ADVISORY.maxFiles || totalBytes > LOAD_BUDGET_ADVISORY.maxTotalBytes || loadsPerMinute < LOAD_BUDGET_ADVISORY.minLoadsPerMinute) {
+      issues.push({
+        severity: "warning",
+        code: "load_budget",
+        message: `Load budget checkup: ${files.length} files, ${(totalBytes / (1024 * 1024)).toFixed(1)}MB total. A full page load fetches up to ${files.length} requests, so the free preview's ${FREE_REQUESTS_PER_MINUTE} requests/minute cap sustains roughly ${loadsPerMinute} full loads per minute before visitors see rate-limit errors. Consider bundling CSS/JS, compressing or lazy-loading images, and inlining small icons. This is advice only \u2014 publishing is not blocked.`
+      });
+    }
+  }
+  const entryHtmlPath = seen.has("index.html") ? "index.html" : void 0;
+  if (!entryHtmlPath && files.length > 0) {
+    issues.push({
+      severity: "error",
+      code: "missing_index_html",
+      message: "No index.html at the root of the output directory. Deploy the built static output, not the source project."
+    });
+  }
+  let htmlLang;
+  let supportedLang;
+  if (entryHtmlPath) {
+    const entry = files.find((f) => f.path === entryHtmlPath);
+    if (entry?.content) {
+      const text2 = safeDecode(entry.content) ?? "";
+      const lang = extractHtmlLang(text2);
+      if (lang)
+        htmlLang = lang;
+      const normalized = normalizeSupportedLang(lang);
+      if (normalized) {
+        supportedLang = normalized;
+      } else if (lang) {
+        issues.push({
+          severity: "warning",
+          code: "unsupported_html_lang",
+          path: entryHtmlPath,
+          message: `html lang="${lang}" is not a supported UI language (en, ja, zh-CN). English will be used for Sakupa surfaces.`
+        });
+      } else {
+        issues.push({
+          severity: "warning",
+          code: "missing_html_lang",
+          path: entryHtmlPath,
+          message: 'The entry HTML has no lang attribute. Add html lang="en" | "ja" | "zh-CN" so Sakupa surfaces match the site language.'
+        });
+      }
+    }
+  }
+  const jsCount = files.filter((f) => ["js", "mjs"].includes(fileExtension(f.path))).length;
+  const looksLikeSpa = htmlPaths.length === 1 && entryHtmlPath === "index.html" && jsCount > 0;
+  const wantsSpa = opts.spaFallbackRequested === true || looksLikeSpa;
+  const spaFallbackConfirmationRequired = wantsSpa && opts.spaFallbackConfirmed !== true;
+  if (opts.spaFallbackRequested === true && opts.spaFallbackConfirmed !== true) {
+    issues.push({
+      severity: "error",
+      code: "spa_fallback_confirmation_required",
+      message: "SPA fallback rewrites unknown paths to index.html and changes normal 404 behavior. It must be explicitly confirmed."
+    });
+  }
+  const ok = issues.every((i) => i.severity !== "error");
+  return {
+    ok,
+    issues,
+    totalBytes,
+    fileCount: files.length,
+    entryHtmlPath,
+    htmlLang,
+    supportedLang,
+    looksLikeSpa,
+    spaFallbackConfirmationRequired
+  };
+}
+function safeDecode(bytes) {
+  try {
+    return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+  } catch {
+    return null;
+  }
+}
+
+// ../core/dist/domain/subscription.js
+var SUBSCRIPTION_WARNING_TEXT = "You are subscribing {billingDomain} to Sakupa Domain Hosting: the {plan} monthly plan (\xA5{priceJpy}/month).\n\nPaying does not prove that you own this domain, does not grant management rights, and does not by itself publish a website: the domain must still pass DNS ownership verification.\n\nIf this site outgrows its plan, Sakupa automatically upgrades the subscription to the next plan (water -> personal -> share -> business) and renewals bill the new plan. There is no metered overage: above the Business plan, growth is limited instead of billed further.\n\nYou can cancel anytime; hosting then runs to the end of the already-paid month and stops.";
+
+// ../core/dist/dto.js
+var CREDENTIAL_HEADER = "x-sakupa-credential";
+var IDEMPOTENCY_HEADER = "x-sakupa-idempotency-key";
+
+// ../core/dist/services/sites.js
+var utf8Decoder = new TextDecoder("utf-8", { fatal: false });
+var utf8Encoder = new TextEncoder();
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/api-client.ts
+var KNOWN_ERROR_CODES = /* @__PURE__ */ new Set([
+  "invalid_request",
+  "validation_failed",
+  "unauthorized",
+  "forbidden",
+  "not_found",
+  "conflict",
+  "state_conflict",
+  "rate_limited",
+  "insufficient_balance",
+  "payment_required",
+  "confirmation_required",
+  "dns_not_verified",
+  "not_deployable",
+  "internal"
+]);
+var HttpApiClient = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async call(method, path, opts = {}) {
+    const headers = {};
+    if (opts.credential !== void 0) headers[CREDENTIAL_HEADER] = opts.credential;
+    if (opts.idempotencyKey !== void 0) headers[IDEMPOTENCY_HEADER] = opts.idempotencyKey;
+    const req = {
+      method,
+      path,
+      headers,
+      ...opts.body !== void 0 ? { body: JSON.stringify(opts.body) } : {}
+    };
+    const res = await this.transport.request(req);
+    if (res.status < 200 || res.status >= 300) {
+      throw this.toError(res.status, res.body);
+    }
+    if (res.body === void 0 || res.body.length === 0) return void 0;
+    return JSON.parse(res.body);
+  }
+  toError(status, body) {
+    if (body) {
+      try {
+        const parsed = JSON.parse(body);
+        const code = parsed?.error?.code;
+        const message = parsed?.error?.message ?? `API request failed with HTTP ${status}`;
+        if (typeof code === "string" && KNOWN_ERROR_CODES.has(code)) {
+          return new SakupaError(code, message, parsed.error.details);
+        }
+        return new SakupaError("internal", message, {
+          originalCode: code,
+          details: parsed?.error?.details
+        });
+      } catch (e) {
+        if (e instanceof SakupaError) throw e;
+      }
+    }
+    return new SakupaError("internal", `API request failed with HTTP ${status}`, {
+      httpStatus: status,
+      body: body?.slice(0, 200)
+    });
+  }
+  async createSite(req, _clientIp) {
+    return this.call("POST", "/v1/sites", { body: req });
+  }
+  async createDeployment(siteId, credential, req) {
+    return this.call(
+      "POST",
+      `/v1/sites/${encodeURIComponent(siteId)}/deployments`,
+      { credential, body: req }
+    );
+  }
+  async finalizeDeployment(deploymentId, siteId, credential) {
+    return this.call(
+      "POST",
+      `/v1/deployments/${encodeURIComponent(deploymentId)}/finalize`,
+      { credential, body: { siteId } }
+    );
+  }
+  async uploadFile(target, body) {
+    await this.transport.upload(target, body);
+  }
+  async refreshSite(siteId, credential) {
+    return this.call(
+      "POST",
+      `/v1/sites/${encodeURIComponent(siteId)}/refresh`,
+      { credential }
+    );
+  }
+  async getSiteStatus(siteId, credential) {
+    return this.call("GET", `/v1/sites/${encodeURIComponent(siteId)}`, {
+      credential
+    });
+  }
+  async deleteSite(siteId, credential) {
+    await this.call("DELETE", `/v1/sites/${encodeURIComponent(siteId)}`, { credential });
+  }
+  async bindDomain(credential, req) {
+    return this.call("POST", "/v1/domains/bind", { credential, body: req });
+  }
+  async checkVerification(verificationId, credential) {
+    return this.call(
+      "POST",
+      `/v1/domains/verifications/${encodeURIComponent(verificationId)}/check`,
+      { credential }
+    );
+  }
+  async recoverDomain(req) {
+    return this.call("POST", "/v1/domains/recover", { body: req });
+  }
+  async completeRecovery(verificationId, req) {
+    return this.call(
+      "POST",
+      `/v1/domains/recover/${encodeURIComponent(verificationId)}/complete`,
+      { body: req }
+    );
+  }
+  /** Wallet-era recharge checkout; unused (kept for SakupaApiClient compatibility). */
+  async createCheckout(req) {
+    return this.call("POST", "/v1/payments/checkout", {
+      body: req,
+      idempotencyKey: req.idempotencyKey
+    });
+  }
+  /** Subscription checkout: a fixed monthly plan for one apex domain (owner-only). */
+  async createPlanCheckout(req, credential) {
+    return this.call("POST", "/v1/payments/checkout", {
+      credential,
+      body: req,
+      idempotencyKey: req.idempotencyKey
+    });
+  }
+  /** Stripe-hosted billing portal (payment method, invoices, cancellation). */
+  async createBillingPortal(apexDomain, credential) {
+    return this.call(
+      "POST",
+      `/v1/billing/${encodeURIComponent(apexDomain)}/portal`,
+      { credential, body: {} }
+    );
+  }
+  async getBillingStatus(apexDomain, credential) {
+    return this.call(
+      "GET",
+      `/v1/billing/${encodeURIComponent(apexDomain)}`,
+      credential !== void 0 ? { credential } : {}
+    );
+  }
+  async setBillingPlan(apexDomain, credential, req) {
+    return this.call(
+      "POST",
+      `/v1/billing/${encodeURIComponent(apexDomain)}/plan`,
+      { credential, body: req }
+    );
+  }
+  async downgradeSite(siteId, credential, req) {
+    return this.call(
+      "POST",
+      `/v1/sites/${encodeURIComponent(siteId)}/downgrade`,
+      { credential, body: req }
+    );
+  }
+  async createTicket(credential, req) {
+    return this.call("POST", "/v1/support/tickets", {
+      credential,
+      body: req
+    });
+  }
+  async reportBug(req, credential) {
+    return this.call("POST", "/v1/support/bug-reports", {
+      ...credential !== void 0 ? { credential } : {},
+      body: req
+    });
+  }
+};
+
+// src/tools/definitions.ts
+import { randomUUID } from "node:crypto";
+import { promises as fs2 } from "node:fs";
+import { join as join3, resolve as resolve2 } from "node:path";
+import { z } from "zod";
+
+// src/analyze/analyzer.ts
+import { promises as fs } from "node:fs";
+import { join, posix, resolve, sep } from "node:path";
+var SERVER_RUNTIME_DEPS = ["express", "koa", "fastify", "hapi", "@hapi/hapi"];
+var DB_RUNTIME_DEPS = [
+  "prisma",
+  "@prisma/client",
+  "mongoose",
+  "pg",
+  "mysql2",
+  "better-sqlite3",
+  "typeorm",
+  "sequelize",
+  "redis",
+  "ioredis"
+];
+var USE_SERVER_SCAN_MAX_FILES = 200;
+var USE_SERVER_SCAN_MAX_BYTES = 256 * 1024;
+var CONTENT_READ_MAX_BYTES = 1024 * 1024;
+var TEXT_CONTENT_EXTENSIONS = /* @__PURE__ */ new Set(["html", "htm", "js", "mjs", "css", "json", "txt", "xml"]);
+var SOURCE_SCAN_EXTENSIONS = /* @__PURE__ */ new Set(["js", "jsx", "ts", "tsx", "mjs", "cjs"]);
+var FORBIDDEN_SEGMENTS_LOWER = new Set(FORBIDDEN_PATH_SEGMENTS.map((s) => s.toLowerCase()));
+async function isDirectory(path) {
+  try {
+    return (await fs.stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function isFile(path) {
+  try {
+    return (await fs.stat(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function readTextIfExists(path, maxBytes = CONTENT_READ_MAX_BYTES) {
+  try {
+    const stat = await fs.stat(path);
+    if (!stat.isFile() || stat.size > maxBytes) return null;
+    return await fs.readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function firstExistingFile(dir, names) {
+  for (const name of names) {
+    const p = join(dir, name);
+    if (await isFile(p)) return p;
+  }
+  return null;
+}
+function extensionOf(path) {
+  const base = path.split("/").pop() ?? "";
+  const idx = base.lastIndexOf(".");
+  if (idx <= 0) return "";
+  return base.slice(idx + 1).toLowerCase();
+}
+async function walkFiles(dir, opts) {
+  const out = [];
+  async function recurse(current, relPrefix) {
+    if (out.length > opts.maxFiles) return;
+    let entries;
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    for (const entry of entries) {
+      if (out.length > opts.maxFiles) return;
+      const rel = relPrefix.length > 0 ? `${relPrefix}/${entry.name}` : entry.name;
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isDirectory()) {
+        if (FORBIDDEN_SEGMENTS_LOWER.has(entry.name.toLowerCase())) continue;
+        if (opts.skipRelDirs?.has(rel)) continue;
+        await recurse(join(current, entry.name), rel);
+      } else if (entry.isFile()) {
+        try {
+          const stat = await fs.stat(join(current, entry.name));
+          out.push({ path: rel, size: stat.size });
+        } catch {
+        }
+      }
+    }
+  }
+  await recurse(dir, "");
+  return out;
+}
+async function readPackageJson(projectDir) {
+  const raw = await readTextIfExists(join(projectDir, "package.json"));
+  if (raw === null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function allDeps(pkg) {
+  return { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
+}
+async function anyFileMatches(dir, predicate) {
+  if (!await isDirectory(dir)) return false;
+  const files = await walkFiles(dir, { maxFiles: 2e3 });
+  return files.some((f) => predicate(f.path.split("/").pop() ?? ""));
+}
+async function detectFramework(projectDir, pkg) {
+  const deps = allDeps(pkg);
+  const ssrRisks = [];
+  const nextConfigPath = await firstExistingFile(projectDir, [
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts",
+    "next.config.cjs"
+  ]);
+  if ("next" in deps || nextConfigPath !== null) {
+    const config = nextConfigPath ? await readTextIfExists(nextConfigPath) : null;
+    const staticExport = config !== null && /output\s*:\s*['"]export['"]/.test(config);
+    if (!staticExport) {
+      ssrRisks.push(
+        `Next.js project without output: 'export' in next.config.* \u2014 the default Next.js build requires a Node.js server. Sakupa only serves static files; add output: 'export' to next.config.* and build locally to produce a static "out" directory.`
+      );
+    }
+    for (const apiDir of ["pages/api", "src/pages/api"]) {
+      if (await isDirectory(join(projectDir, apiDir))) {
+        ssrRisks.push(
+          `API routes (${apiDir}/) require a server runtime and will not run on Sakupa. Remove them or move their logic to build time before static export.`
+        );
+        break;
+      }
+    }
+    for (const appDir of ["app", "src/app"]) {
+      if (await anyFileMatches(
+        join(projectDir, appDir),
+        (base) => /^route\.(ts|js|tsx|jsx|mjs)$/.test(base)
+      )) {
+        ssrRisks.push(
+          `App Router route handlers (${appDir}/**/route.ts|js) require a server runtime and will not run on Sakupa.`
+        );
+        break;
+      }
+    }
+    if (await firstExistingFile(projectDir, [
+      "middleware.ts",
+      "middleware.js",
+      "src/middleware.ts",
+      "src/middleware.js"
+    ]) !== null) {
+      ssrRisks.push("middleware.(ts|js) runs on a server/edge runtime and will not run on Sakupa.");
+    }
+    return {
+      framework: "next",
+      outputCandidates: ["out"],
+      buildCommandHint: "npm run build",
+      ssrRisks
+    };
+  }
+  const nuxtConfigPath = await firstExistingFile(projectDir, [
+    "nuxt.config.ts",
+    "nuxt.config.js",
+    "nuxt.config.mjs"
+  ]);
+  if ("nuxt" in deps || "nuxt3" in deps || nuxtConfigPath !== null) {
+    for (const serverDir of ["server/api", "server/routes"]) {
+      if (await isDirectory(join(projectDir, serverDir))) {
+        ssrRisks.push(
+          `Nuxt server handlers (${serverDir}/) require a server runtime and will not run on Sakupa. Use static generation (npx nuxi generate) and deploy .output/public.`
+        );
+      }
+    }
+    return {
+      framework: "nuxt",
+      outputCandidates: [".output/public", "dist"],
+      buildCommandHint: "npm run generate (or npx nuxi generate)",
+      ssrRisks
+    };
+  }
+  const astroConfigPath = await firstExistingFile(projectDir, [
+    "astro.config.mjs",
+    "astro.config.js",
+    "astro.config.ts"
+  ]);
+  if ("astro" in deps || astroConfigPath !== null) {
+    const config = astroConfigPath ? await readTextIfExists(astroConfigPath) : null;
+    if (config !== null && /output\s*:\s*['"]server['"]/.test(config)) {
+      ssrRisks.push(
+        "Astro config sets output: 'server' (SSR). Sakupa only serves static files; use the default static output (or output: 'static') and build locally."
+      );
+    }
+    return {
+      framework: "astro",
+      outputCandidates: ["dist"],
+      buildCommandHint: "npm run build",
+      ssrRisks
+    };
+  }
+  if ("@sveltejs/kit" in deps) {
+    if ("@sveltejs/adapter-node" in deps) {
+      ssrRisks.push(
+        "SvelteKit is configured with @sveltejs/adapter-node, which produces a Node.js server. Sakupa only serves static files; switch to @sveltejs/adapter-static and rebuild."
+      );
+    } else if (!("@sveltejs/adapter-static" in deps)) {
+      ssrRisks.push(
+        "SvelteKit requires @sveltejs/adapter-static to produce a fully static build. Install and configure it, then build locally."
+      );
+    }
+    if (await anyFileMatches(join(projectDir, "src/routes"), (base) => base.startsWith("+server."))) {
+      ssrRisks.push(
+        "SvelteKit +server.* endpoint files require a server runtime and will not run on Sakupa."
+      );
+    }
+    return {
+      framework: "sveltekit",
+      outputCandidates: ["build"],
+      buildCommandHint: "npm run build",
+      ssrRisks
+    };
+  }
+  if ("react-scripts" in deps) {
+    return {
+      framework: "create-react-app",
+      outputCandidates: ["build"],
+      buildCommandHint: "npm run build",
+      ssrRisks
+    };
+  }
+  const viteConfigPath = await firstExistingFile(projectDir, [
+    "vite.config.ts",
+    "vite.config.js",
+    "vite.config.mjs"
+  ]);
+  if ("vite" in deps || viteConfigPath !== null) {
+    let framework = "vite";
+    if ("vue" in deps) framework = "vue (vite)";
+    else if ("react" in deps) framework = "react (vite)";
+    else if ("svelte" in deps) framework = "svelte (vite)";
+    return {
+      framework,
+      outputCandidates: ["dist"],
+      buildCommandHint: "npm run build",
+      ssrRisks
+    };
+  }
+  return null;
+}
+function serverAndDbDepRisks(pkg, hasStaticOutput) {
+  const deps = allDeps(pkg);
+  const risks = [];
+  for (const name of SERVER_RUNTIME_DEPS) {
+    if (name in deps) {
+      risks.push(
+        hasStaticOutput ? `Warning: dependency "${name}" is a server framework. Sakupa never runs it online \u2014 only the static output is served. Using it locally at build time is fine.` : `Dependency "${name}" is a server framework. Sakupa does not host server runtimes; only prebuilt static output can be deployed.`
+      );
+    }
+  }
+  for (const name of DB_RUNTIME_DEPS) {
+    if (name in deps) {
+      risks.push(
+        hasStaticOutput ? `Warning: dependency "${name}" is a database/runtime client. Sakupa never runs it online \u2014 using a database locally at build time to generate static pages is fine.` : `Dependency "${name}" is a database/runtime client. Sakupa does not host databases or server runtimes; generate static pages locally and deploy only the output.`
+      );
+    }
+  }
+  return risks;
+}
+async function scanForUseServer(projectDir, skipRelDirs) {
+  const files = await walkFiles(projectDir, { maxFiles: USE_SERVER_SCAN_MAX_FILES, skipRelDirs });
+  let scanned = 0;
+  for (const file of files) {
+    if (scanned >= USE_SERVER_SCAN_MAX_FILES) break;
+    if (!SOURCE_SCAN_EXTENSIONS.has(extensionOf(file.path))) continue;
+    scanned += 1;
+    const text2 = await readTextIfExists(join(projectDir, file.path), USE_SERVER_SCAN_MAX_BYTES);
+    if (text2 !== null && /['"]use server['"]/.test(text2)) return true;
+  }
+  return false;
+}
+function normalizeOutputDir(outputDir) {
+  const normalized = posix.normalize(outputDir.replaceAll(sep, "/")).replace(/\/+$/, "");
+  return normalized === "" ? "." : normalized;
+}
+async function analyzeProject(projectDir, opts = {}) {
+  const root = resolve(projectDir);
+  const pkg = await readPackageJson(root);
+  const detection = await detectFramework(root, pkg);
+  const ssrRisks = [...detection?.ssrRisks ?? []];
+  const hasBuildScript = typeof pkg?.scripts?.["build"] === "string";
+  const buildRequired = detection !== null || hasBuildScript;
+  let outputDirRel;
+  let outputDirExists = false;
+  if (opts.outputDir !== void 0) {
+    outputDirRel = normalizeOutputDir(opts.outputDir);
+    const abs = resolve(root, outputDirRel);
+    if (!abs.startsWith(root)) {
+      outputDirRel = ".";
+      outputDirExists = false;
+    } else {
+      outputDirExists = await isDirectory(abs) || outputDirRel === "." && await isDirectory(root);
+    }
+  } else if (detection) {
+    for (const candidate of detection.outputCandidates) {
+      if (await isDirectory(join(root, candidate))) {
+        outputDirRel = candidate;
+        outputDirExists = true;
+        break;
+      }
+    }
+    if (outputDirRel === void 0) {
+      outputDirRel = detection.outputCandidates[0] ?? "dist";
+      outputDirExists = false;
+    }
+  } else if (!buildRequired) {
+    outputDirRel = ".";
+    outputDirExists = true;
+  } else if (hasBuildScript) {
+    for (const candidate of ["dist", "build", "out", "public"]) {
+      if (await isFile(join(root, candidate, "index.html"))) {
+        outputDirRel = candidate;
+        outputDirExists = true;
+        break;
+      }
+    }
+  }
+  const projectType = detection ? "framework" : outputDirRel !== void 0 && !buildRequired ? "plain-static" : "unknown";
+  const buildCommandHint = detection ? detection.buildCommandHint : hasBuildScript ? "npm run build" : void 0;
+  if (pkg !== null && buildRequired) {
+    const skip = /* @__PURE__ */ new Set();
+    if (outputDirRel !== void 0 && outputDirRel !== ".") skip.add(outputDirRel);
+    if (await scanForUseServer(root, skip)) {
+      ssrRisks.push(
+        "Source files contain 'use server' directives (server actions). Server actions require a server runtime and will not run on Sakupa."
+      );
+    }
+  }
+  if (outputDirRel === void 0 || !outputDirExists) {
+    ssrRisks.push(...serverAndDbDepRisks(pkg, false));
+    const sourceWithoutBuild = pkg !== null && buildRequired && (await isDirectory(join(root, "src")) || await isDirectory(join(root, "pages")));
+    let suggestedNextAction2;
+    if (opts.outputDir !== void 0) {
+      suggestedNextAction2 = `The requested output directory "${opts.outputDir}" does not exist. Build the project locally first (${buildCommandHint ?? "npm run build"}) or pass the correct directory, then re-run analyze_site.`;
+    } else if (ssrRisks.length > 0 && detection) {
+      suggestedNextAction2 = `This ${detection.framework} project appears to require a server runtime (see ssrRisks) and no static output directory was found. Convert it to static output (e.g. Next.js output: 'export', Nuxt generate, Astro static, SvelteKit adapter-static), run the build locally (${buildCommandHint ?? "npm run build"}), then re-run analyze_site.`;
+    } else if (sourceWithoutBuild || detection && !outputDirExists) {
+      suggestedNextAction2 = `This looks like a source project, not built static output. Run the build locally (${buildCommandHint ?? "npm run build"}) then re-run analyze_site.`;
+    } else {
+      suggestedNextAction2 = "No deployable static output was found. Create an index.html (or build the project locally so a static output directory exists), then re-run analyze_site.";
+    }
+    return {
+      projectType,
+      ...detection ? { framework: detection.framework } : {},
+      ...outputDirRel !== void 0 ? { recommendedOutputDir: outputDirRel } : {},
+      outputDirExists: false,
+      ...buildCommandHint !== void 0 ? { buildCommandHint } : {},
+      entryHtmlFound: false,
+      langSupported: false,
+      totalBytes: 0,
+      fileCount: 0,
+      issues: [],
+      ssrRisks,
+      spa: { looksLikeSpa: false, fallbackRecommended: false, confirmationRequired: false },
+      deployable: false,
+      suggestedNextAction: suggestedNextAction2
+    };
+  }
+  const outputAbs = outputDirRel === "." ? root : resolve(root, outputDirRel);
+  const walked = await walkFiles(outputAbs, { maxFiles: MAX_FILE_COUNT + 1 });
+  const candidates = [];
+  for (const file of walked) {
+    const ext = extensionOf(file.path);
+    let content;
+    if (TEXT_CONTENT_EXTENSIONS.has(ext) && file.size <= CONTENT_READ_MAX_BYTES) {
+      try {
+        content = new Uint8Array(await fs.readFile(join(outputAbs, file.path)));
+      } catch {
+        content = void 0;
+      }
+    }
+    candidates.push({ path: file.path, size: file.size, ...content ? { content } : {} });
+  }
+  const validation = validateDeployableFiles(candidates, {
+    mode: "free",
+    ...opts.spaFallbackRequested !== void 0 ? { spaFallbackRequested: opts.spaFallbackRequested } : {},
+    ...opts.spaFallbackConfirmed !== void 0 ? { spaFallbackConfirmed: opts.spaFallbackConfirmed } : {}
+  });
+  ssrRisks.push(...serverAndDbDepRisks(pkg, true));
+  const deployable = validation.ok && walked.length > 0;
+  const spa = {
+    looksLikeSpa: validation.looksLikeSpa,
+    fallbackRecommended: validation.looksLikeSpa,
+    confirmationRequired: validation.spaFallbackConfirmationRequired
+  };
+  let suggestedNextAction;
+  if (!deployable) {
+    const firstError = validation.issues.find((i) => i.severity === "error");
+    if (firstError?.code === "missing_index_html") {
+      suggestedNextAction = `No index.html at the root of "${outputDirRel}". Deploy the built static output (the directory whose root contains index.html), not the source project. Build locally first if needed (${buildCommandHint ?? "npm run build"}), then re-run analyze_site.`;
+    } else if (firstError?.code === "spa_fallback_confirmation_required") {
+      suggestedNextAction = "SPA fallback rewrites unknown paths to index.html and changes normal 404 behavior. Confirm it explicitly: re-run with spaFallbackRequested: true and spaFallbackConfirmed: true.";
+    } else {
+      suggestedNextAction = "Fix the listed issues (remove forbidden/secret files, reduce size, add missing entry HTML), then re-run analyze_site.";
+    }
+  } else if (spa.confirmationRequired) {
+    suggestedNextAction = `The output in "${outputDirRel}" is deployable, but it looks like a single-page app. Decide about SPA fallback first: run deploy_site with spaFallback: true and spaFallbackConfirmed: true to enable it, or with spaFallbackConfirmed: true alone to deploy without fallback.`;
+  } else {
+    suggestedNextAction = `Run deploy_site to publish the static output in "${outputDirRel}".`;
+  }
+  return {
+    projectType,
+    ...detection ? { framework: detection.framework } : {},
+    recommendedOutputDir: outputDirRel,
+    outputDirExists: true,
+    ...buildCommandHint !== void 0 ? { buildCommandHint } : {},
+    entryHtmlFound: validation.entryHtmlPath !== void 0,
+    ...validation.htmlLang !== void 0 ? { htmlLang: validation.htmlLang } : {},
+    langSupported: validation.supportedLang !== void 0,
+    totalBytes: validation.totalBytes,
+    fileCount: validation.fileCount,
+    issues: validation.issues,
+    ssrRisks,
+    spa,
+    deployable,
+    suggestedNextAction,
+    ...deployable ? { files: walked.map((f) => ({ path: f.path, size: f.size })) } : {}
+  };
+}
+
+// src/project-file.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+var SITE_DIR = ".sakupa";
+var SITE_FILE = "site.json";
+function siteFilePath(projectDir) {
+  return join2(projectDir, SITE_DIR, SITE_FILE);
+}
+function readSiteFile(projectDir) {
+  const path = siteFilePath(projectDir);
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    if (typeof parsed.siteId !== "string" || parsed.siteId.length === 0) return null;
+    if (typeof parsed.credential !== "string" || parsed.credential.length === 0) return null;
+    return {
+      siteId: parsed.siteId,
+      credential: parsed.credential,
+      createdAt: typeof parsed.createdAt === "string" ? parsed.createdAt : "",
+      apiBaseUrl: typeof parsed.apiBaseUrl === "string" ? parsed.apiBaseUrl : "",
+      ...typeof parsed.shortId === "string" ? { shortId: parsed.shortId } : {},
+      ...typeof parsed.url === "string" ? { url: parsed.url } : {},
+      ...typeof parsed.billingDomain === "string" ? { billingDomain: parsed.billingDomain } : {},
+      ...typeof parsed.billingDomainId === "string" ? { billingDomainId: parsed.billingDomainId } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function writeSiteFile(projectDir, file) {
+  const dir = join2(projectDir, SITE_DIR);
+  mkdirSync(dir, { recursive: true });
+  const path = join2(dir, SITE_FILE);
+  writeFileSync(path, `${JSON.stringify(file, null, 2)}
+`, "utf8");
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
+
+// src/version.ts
+var MCP_VERSION = "0.1.0";
+var CLIENT_TYPE = "sakupa-mcp";
+
+// src/tools/context.ts
+function requireSiteFile(ctx) {
+  const file = readSiteFile(ctx.projectDir);
+  if (!file) {
+    throw new SakupaError(
+      "not_found",
+      `No .sakupa/site.json found in ${ctx.projectDir}. This project has no Sakupa site binding yet \u2014 run deploy_site first to publish it (the management credential will be stored locally in .sakupa/site.json). If this was a paid custom-domain site whose project file was lost, use recover_domain_site instead.`
+    );
+  }
+  return file;
+}
+function toolError(e) {
+  if (isSakupaError(e)) {
+    let text2 = `Error [${e.code}]: ${e.message}`;
+    if (e.details !== void 0) {
+      text2 += `
+Details: ${JSON.stringify(e.details, null, 2)}`;
+    }
+    return { content: [{ type: "text", text: text2 }], isError: true };
+  }
+  const message = e instanceof Error ? e.message : String(e);
+  return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+}
+
+// src/tools/definitions.ts
+function text(t) {
+  return { content: [{ type: "text", text: t }] };
+}
+function textJson(header, obj) {
+  return text(`${header}
+${JSON.stringify(obj, null, 2)}`);
+}
+var planEnum = z.enum(["water", "personal", "share", "business"]);
+var severityEnum = z.enum(["low", "medium", "high", "critical"]);
+function planCatalog() {
+  return TIER_ORDER.map((p) => `${p} \xA5${tierPriceJpy(p)}/month`).join(", ");
+}
+function subscriptionWarning(domain, plan) {
+  return SUBSCRIPTION_WARNING_TEXT.replaceAll("{billingDomain}", domain).replaceAll("{plan}", plan).replaceAll("{priceJpy}", String(tierPriceJpy(plan)));
+}
+var ticketCategoryEnum = z.enum([
+  "billing",
+  "payment",
+  "refund_review",
+  "chargeback_review",
+  "domain_verification",
+  "deployment",
+  "serving",
+  "bug_report",
+  "abuse",
+  "other"
+]);
+function analysisSummary(analysis) {
+  const { files: _files, ...rest } = analysis;
+  return rest;
+}
+function notDeployableResult(analysis) {
+  return textJson(
+    `This project is NOT deployable as-is. No files were uploaded and no API call was made.
+Next action: ${analysis.suggestedNextAction}
+Analysis:`,
+    analysisSummary(analysis)
+  );
+}
+function spaConfirmationResult(analysis) {
+  return text(
+    `SPA fallback confirmation required \u2014 nothing was deployed yet.
+
+This site looks like a single-page application (one index.html plus JavaScript). SPA fallback rewrites every unknown path to index.html so client-side routes work, but it CHANGES normal 404 behavior: visitors never see a not-found page.
+
+Please ask the user to choose, then re-run deploy_site with:
+- spaFallback: true, spaFallbackConfirmed: true  -> enable SPA fallback
+- spaFallbackConfirmed: true (spaFallback omitted or false) -> deploy WITHOUT fallback (unknown paths return 404)
+
+Output directory: "${analysis.recommendedOutputDir ?? "."}", ${analysis.fileCount} files.`
+  );
+}
+async function uploadAll(ctx, targets, files, outputAbs) {
+  for (let i = 0; i < targets.length; i++) {
+    const target = targets[i];
+    if (!target) continue;
+    const match = files.find((f) => f.path === target.path) ?? files.find((f) => target.path.endsWith(`/${f.path}`)) ?? (targets.length === files.length ? files[i] : void 0);
+    if (!match) {
+      throw new SakupaError(
+        "internal",
+        `No local file matches upload target "${target.path}"; aborting upload.`
+      );
+    }
+    const bytes = new Uint8Array(await fs2.readFile(join3(outputAbs, match.path)));
+    await ctx.client.uploadFile(target, bytes);
+  }
+  return targets.length;
+}
+function registerTools(server, ctx) {
+  server.registerTool(
+    "analyze_site",
+    {
+      description: "Analyze the local project and decide whether it can be deployed as a static site. Detects the framework, the built static output directory (dist/build/out/...), missing index.html, SSR/API-route/database-runtime risks, SPA fallback needs, forbidden files (secrets, .env, archives, media) and size limits. Sakupa deploys ONLY prebuilt static output \u2014 never source, secrets or server code. Run this before deploy_site.",
+      inputSchema: {
+        outputDir: z.string().optional().describe("Output directory relative to the project root (overrides detection)."),
+        spaFallbackRequested: z.boolean().optional().describe("User asked for SPA fallback (unknown paths rewritten to index.html)."),
+        spaFallbackConfirmed: z.boolean().optional().describe("User explicitly confirmed the SPA fallback 404-behavior change.")
+      }
+    },
+    async (args) => {
+      try {
+        const analysis = await analyzeProject(ctx.projectDir, {
+          ...args.outputDir !== void 0 ? { outputDir: args.outputDir } : {},
+          ...args.spaFallbackRequested !== void 0 ? { spaFallbackRequested: args.spaFallbackRequested } : {},
+          ...args.spaFallbackConfirmed !== void 0 ? { spaFallbackConfirmed: args.spaFallbackConfirmed } : {}
+        });
+        return textJson(
+          `Analysis of ${ctx.projectDir}
+Next action: ${analysis.suggestedNextAction}`,
+          analysisSummary(analysis)
+        );
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+  server.registerTool(
+    "deploy_site",
+    {
+      description: `Deploy the local static output to Sakupa. First deploy creates a free temporary site (valid ${FREE_SITE_TTL_HOURS}h, public URL like https://{shortId}.sakupa.com) and stores the management credential in .sakupa/site.json. Later runs update the existing site and refresh its validity. Runs analyze_site first and refuses to upload source projects, secrets, .env files, archives, media or server code. Never uploads anything when the analysis says the project is not deployable.`,
+      inputSchema: {
+        outputDir: z.string().optional().describe("Output directory relative to the project root (overrides detection)."),
+        spaFallback: z.boolean().optional().describe("Enable SPA fallback (requires spaFallbackConfirmed: true)."),
+        spaFallbackConfirmed: z.boolean().optional().describe("User explicitly confirmed the SPA fallback 404-behavior change."),
+        lang: z.string().optional().describe("Site language override (en | ja | zh-CN); defaults to the html lang.")
+      }
+    },
+    async (args) => {
+      try {
+        const analysis = await analyzeProject(ctx.projectDir, {
+          ...args.outputDir !== void 0 ? { outputDir: args.outputDir } : {},
+          ...args.spaFallback !== void 0 ? { spaFallbackRequested: args.spaFallback } : {},
+          ...args.spaFallbackConfirmed !== void 0 ? { spaFallbackConfirmed: args.spaFallbackConfirmed } : {}
+        });
+        if (analysis.spa.confirmationRequired && args.spaFallbackConfirmed !== true) {
+          return spaConfirmationResult(analysis);
+        }
+        if (!analysis.deployable || !analysis.files) {
+          return notDeployableResult(analysis);
+        }
+        const files = analysis.files;
+        const manifest = files.map((f) => ({ path: f.path, size: f.size }));
+        const outputAbs = resolve2(ctx.projectDir, analysis.recommendedOutputDir ?? ".");
+        const existing = readSiteFile(ctx.projectDir);
+        if (!existing) {
+          const created = await ctx.client.createSite({
+            manifest,
+            ...args.lang !== void 0 ? { lang: args.lang } : {},
+            spaFallback: args.spaFallback === true,
+            ...args.spaFallbackConfirmed !== void 0 ? { spaFallbackConfirmed: args.spaFallbackConfirmed } : {}
+          });
+          const uploaded2 = await uploadAll(ctx, created.uploadTargets, files, outputAbs);
+          const finalized2 = await ctx.client.finalizeDeployment(
+            created.deploymentId,
+            created.siteId,
+            created.credential
+          );
+          writeSiteFile(ctx.projectDir, {
+            siteId: created.siteId,
+            shortId: created.shortId,
+            url: finalized2.url,
+            credential: created.credential,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            apiBaseUrl: ctx.apiBaseUrl
+          });
+          return text(
+            `Site published: ${finalized2.url}
+Files uploaded: ${uploaded2} (${finalized2.totalBytes} bytes)
+` + (finalized2.expiresAt ? `Expires at: ${finalized2.expiresAt}
+` : "") + `
+This is a FREE temporary preview: it stays live for ${FREE_SITE_TTL_HOURS} hours. Deploying again or calling refresh_site extends the validity. The management credential was saved to .sakupa/site.json \u2014 keep that file: it is the only way to manage this free site.
+` + (finalized2.warnings.length > 0 ? `
+Warnings:
+${JSON.stringify(finalized2.warnings, null, 2)}` : "")
+          );
+        }
+        const deployment = await ctx.client.createDeployment(existing.siteId, existing.credential, {
+          manifest,
+          ...args.lang !== void 0 ? { lang: args.lang } : {},
+          spaFallback: args.spaFallback === true,
+          ...args.spaFallbackConfirmed !== void 0 ? { spaFallbackConfirmed: args.spaFallbackConfirmed } : {}
+        });
+        const uploaded = await uploadAll(ctx, deployment.uploadTargets, files, outputAbs);
+        const finalized = await ctx.client.finalizeDeployment(
+          deployment.deploymentId,
+          existing.siteId,
+          existing.credential
+        );
+        writeSiteFile(ctx.projectDir, { ...existing, url: finalized.url });
+        return text(
+          `Site updated: ${finalized.url}
+Files uploaded: ${uploaded} (${finalized.totalBytes} bytes)
+` + (finalized.expiresAt ? `Validity refreshed \u2014 expires at: ${finalized.expiresAt}
+` : "") + (finalized.mode === "free" ? `
+Reminder: free sites stay live for ${FREE_SITE_TTL_HOURS} hours after the last deploy or refresh_site call.
+` : "") + (finalized.warnings.length > 0 ? `
+Warnings:
+${JSON.stringify(finalized.warnings, null, 2)}` : "")
+        );
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+  server.registerTool(
+    "refresh_site",
+    {
+      description: "Refresh the validity of the free temporary site WITHOUT uploading content. Uses the local credential in .sakupa/site.json.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const site = requireSiteFile(ctx);
+        const res = await ctx.client.refreshSite(site.siteId, site.credential);
+        return text(
+          `Site validity refreshed. New expiry: ${res.expiresAt}
+Free sites stay live for ${FREE_SITE_TTL_HOURS} hours after each deploy or refresh.`
+        );
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+  server.registerTool(
+    "site_status",
+    {
+      description: "Show the current status of this project's Sakupa site: URL, mode (free/paid), expiry, domain binding, size, last deployment and warnings.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const site = requireSiteFile(ctx);
+        const res = await ctx.client.getSiteStatus(site.siteId, site.credential);
+        return textJson("Site status:", res);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+  server.registerTool(
+    "bind_domain",
+    {
+      description: `Start or continue binding a custom domain to this site (the paid long-term mode). Ownership is proven ONLY by DNS control of the registered apex domain \u2014 payment never grants ownership. The billing subject is always the apex domain: all its subdomains share one hosting subscription (plans: ${planCatalog()}). The apex domain needs an ACTIVE subscription (see subscribe_domain) before paid configuration can start. Call again with verificationId to check DNS verification progress.`,
+      inputSchema: {
+        hostname: z.string().describe('Hostname to bind, e.g. "example.com" or "www.example.com".'),
+        verificationId: z.string().optional().describe("Check an existing DNS verification instead of starting a new one.")
+      }
+    },
+    async (args) => {
+      try {
+        const site = requireSiteFile(ctx);
+        if (args.verificationId !== void 0) {
+          const res2 = await ctx.client.checkVerification(args.verificationId, site.credential);
+          if (res2.status === "verified") {
+            writeSiteFile(ctx.projectDir, { ...site, billingDomain: res2.apexDomain });
+          }
+          return text(
+            `DNS verification ${res2.verificationId}: ${res2.status}
+${res2.message}
+` + (res2.provisioningJobId ? `Provisioning started (job ${res2.provisioningJobId}). HTTPS certificate and CDN setup are in progress; check again with bind_domain + verificationId later.
+` : "") + (res2.pendingDnsRecords.length > 0 ? `
+DNS records still required:
+${JSON.stringify(res2.pendingDnsRecords, null, 2)}` : "")
+          );
+        }
+        const req = {
+          siteId: site.siteId,
+          hostname: args.hostname
+        };
+        const res = await ctx.client.bindDomain(site.credential, req);
+        writeSiteFile(ctx.projectDir, {
+          ...site,
+          billingDomain: res.apexDomain,
+          billingDomainId: res.billingDomainId
+        });
+        const servingHint = res.isApex ? `"${res.hostname}" is an apex domain: your DNS provider must support ALIAS, ANAME, CNAME flattening, or alias records to point it at the assigned CDN domain.` : `"${res.hostname}" is a subdomain: create a CNAME record pointing it at the assigned CDN domain once provisioning completes.`;
+        return text(
+          `Domain binding started for ${res.hostname}.
+
+Billing subject: the apex domain "${res.apexDomain}". Subdomains of ${res.apexDomain} cannot be separate billing subjects \u2014 they all share this domain hosting subscription.
+
+1. Prove control of ${res.apexDomain} by creating this DNS record:
+   name:  ${res.verificationRecord.name}
+   type:  ${res.verificationRecord.type}
+   value: ${res.verificationRecord.value}
+   Ownership and management authority come ONLY from DNS control. Paying for the subscription never grants ownership, management rights, or activation.
+
+2. Serving DNS (after verification): ${servingHint}
+   Server guidance: ${res.servingInstructions}
+
+Then run bind_domain again with verificationId: "${res.verificationId}" to check verification and start provisioning.`
+        );
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+  server.registerTool(
+    "billing_status",
+    {
+      description: "Show the hosting subscription status of an apex billing domain: current plan, payment state, current paid period, reconciled usage, estimated usage tier, next renewal, risks and the per-site usage breakdown. Reads are based on the latest reconciled snapshot.",
+      inputSchema: {
+        domain: z.string().optional().describe("Apex billing domain; defaults to the domain bound in .sakupa/site.json.")
+      }
+    },
+    async (args) => {
+      try {
+        const site = readSiteFile(ctx.projectDir);
+        const domain = args.domain ?? site?.billingDomain;
+        if (!domain) {
+          throw new SakupaError(
+            "invalid_request",
+            'No domain given and this project has no bound billing domain. Pass domain, e.g. billing_status { domain: "example.com" }.'
+          );
+        }
+        const res = await ctx.client.getBillingStatus(domain, site?.credential);
+        const lines = [
+          `Billing status for ${res.paidSubject} (service status: ${res.serviceStatus})`,
+          res.committedTier ? `Plan: ${res.committedTier} (\xA5${tierPriceJpy(res.committedTier)}/month)` : "Plan: (no subscription yet)",
+          res.subscriptionStatus ? `Subscription payment state: ${res.subscriptionStatus}` : void 0,
+          res.cancelAtCycleEnd ? "Renewal: CANCELED \u2014 hosting stops at the end of the already-paid month" : void 0,
+          res.currentCycleStart ? `Current paid period: ${res.currentCycleStart} -> ${res.currentCycleEnd ?? "?"}` : void 0,
+          res.estimatedUsageTier ? `Estimated usage tier: ${res.estimatedUsageTier}` : void 0,
+          res.lastReconciledAt ? `Last usage reconciliation: ${res.lastReconciledAt}` : void 0,
+          res.nextSettlementAt ? `Next renewal: ${res.nextSettlementAt}` : void 0,
+          res.risks.unpaid ? "ATTENTION: renewal payment failed \u2014 update the payment method (manage_billing) to keep the custom domain hosted." : void 0,
+          res.ownerView ? void 0 : "Note: public view (no valid owner credential presented)."
+        ].filter((l) => l !== void 0);
+        return textJson(`${lines.join("\n")}
+
+Full status:`, res);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+  server.registerTool(
+    "subscribe_domain",
+    {
+      description: `Create a Stripe Checkout link that subscribes an apex domain to a Sakupa Domain Hosting monthly plan (${planCatalog()}). Owner-only: requires this project's site credential (.sakupa/site.json) \u2014 deploy_site first; a lost credential means payment is not possible. One domain = one subscription; if the site outgrows its plan, Sakupa auto-upgrades to the next plan (capped at Business, where growth is limited instead of billed further). Paying never proves domain ownership and never activates a website \u2014 DNS verification (bind_domain) is still required. Card details are entered only on the Stripe-hosted page \u2014 never through the AI tool. Without confirm: true this tool only shows the mandatory disclosure and makes no API call.`,
+      inputSchema: {
+        domain: z.string().describe('Apex domain to subscribe, e.g. "example.com".'),
+        plan: planEnum.describe(
+          "Monthly plan: water (very light personal pages), personal (personal brand / small shop), share (small-business site), business (steadier traffic, more headroom)."
+        ),
+        confirm: z.boolean().optional().describe("User read the subscription disclosure and confirmed. Required to proceed.")
+      }
+    },
+    async (args) => {
+      try {
+        const site = requireSiteFile(ctx);
+        if (args.confirm !== true) {
+          return text(
+            `${subscriptionWarning(args.domain, args.plan)}
+
+No checkout link was created yet. Please show this disclosure to the user and, after their explicit confirmation, re-run subscribe_domain with confirm: true.`
+          );
+        }
+        const res = await ctx.client.createPlanCheckout(
+          {
+            siteId: site.siteId,
+            domain: args.domain,
+            plan: args.plan,
+            idempotencyKey: randomUUID(),
+            confirmPlan: true
+          },
+          site.credential
+        );
+        return text(
+          `Stripe Checkout link \u2014 Sakupa Domain Hosting for ${res.apexDomain}: ${res.plan} plan, \xA5${res.monthlyPriceJpy}/month
+${res.checkoutUrl}
+
+Open this link in a browser to subscribe. Card data is entered only on the Stripe-hosted page \u2014 never give card numbers, passwords or security codes to the AI tool.
+Reminder: the subscription is payment state only. It grants no domain ownership and no management rights; the domain must still pass DNS verification (bind_domain) before long-term hosting activates.`
+        );
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+  server.registerTool(
+    "manage_billing",
+    {
+      description: "Open the Stripe-hosted billing portal for the bound apex domain: update the payment method, view invoices, or cancel the subscription. All billing operations happen on the Stripe-hosted page \u2014 never inside the AI tool. Requires the local site credential (.sakupa/site.json) of a site bound to the domain.",
+      inputSchema: {
+        domain: z.string().optional().describe("Apex billing domain; defaults to the domain bound in .sakupa/site.json.")
+      }
+    },
+    async (args) => {
+      try {
+        const site = requireSiteFile(ctx);
+        const domain = args.domain ?? site.billingDomain;
+        if (!domain) {
+          throw new SakupaError(
+            "invalid_request",
+            "No domain given and this project has no bound billing domain. Pass domain explicitly."
+          );
+        }
+        const res = await ctx.client.createBillingPortal(domain, site.credential);
+        return text(
+          `Stripe billing portal for ${res.apexDomain}:
+${res.portalUrl}
+
+Open this link in a browser to update the payment method, view invoices, or manage the subscription. The link is temporary \u2014 create a fresh one when needed.`
+        );
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+  server.registerTool(
+    "recover_domain_site",
+    {
+      description: "Recover management control of a paid custom-domain site after losing the local project, by proving DNS control of the apex domain. By default, completing recovery REVOKES all previous local credentials for the site. Call first with the hostname to get the DNS record, then again with verificationId to complete recovery (writes a new .sakupa/site.json and returns a download link for the current site content).",
+      inputSchema: {
+        hostname: z.string().describe('Hostname of the site to recover, e.g. "www.example.com".'),
+        verificationId: z.string().optional().describe("Complete a recovery previously started for this hostname."),
+        preserveExistingCredentials: z.boolean().optional().describe("Explicitly keep old local credentials working (default: revoke them all).")
+      }
+    },
+    async (args) => {
+      try {
+        if (args.verificationId === void 0) {
+          const res2 = await ctx.client.recoverDomain({ hostname: args.hostname });
+          return text(
+            `Recovery started for ${args.hostname} (apex billing domain: ${res2.apexDomain}).
+
+Create this DNS record to prove apex-domain control:
+   name:  ${res2.verificationRecord.name}
+   type:  ${res2.verificationRecord.type}
+   value: ${res2.verificationRecord.value}
+
+${res2.message}
+
+IMPORTANT: completing recovery revokes ALL previous local authorizations for this site by default (this protects you if the old project or its credential leaked). If you want to keep the old credentials working, pass preserveExistingCredentials: true when completing.
+
+After the DNS record resolves, re-run recover_domain_site with verificationId: "${res2.verificationId}".`
+          );
+        }
+        const res = await ctx.client.completeRecovery(args.verificationId, {
+          ...args.preserveExistingCredentials !== void 0 ? { preserveExistingCredentials: args.preserveExistingCredentials } : {}
+        });
+        writeSiteFile(ctx.projectDir, {
+          siteId: res.siteId,
+          billingDomain: res.billingDomain,
+          credential: res.credential,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          apiBaseUrl: ctx.apiBaseUrl
+        });
+        return text(
+          `Recovery complete for ${res.billingDomain}.
+Site: ${res.siteId} (hostnames: ${res.boundHostnames.join(", ") || "(none)"})
+Previous credentials revoked: ${res.revokedPreviousCredentials ? "YES" : "no (preserved on request)"}
+
+A NEW management credential was written to .sakupa/site.json in this project \u2014 this project now manages the site.
+
+Download the current site content (signed URL):
+${res.archiveUrl}`
+        );
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+  server.registerTool(
+    "set_billing_plan",
+    {
+      description: `Change the hosting plan of the apex billing domain or cancel/re-enable renewal. Plans: ${planCatalog()}. Plan changes go through the Stripe subscription; renewals bill the new plan. Auto-upgrade (one plan up when usage exceeds the current plan, capped at Business) is built in and not configurable. The API returns the billing consequences first; explicit owner confirmation (confirm: true) is required before anything is applied.`,
+      inputSchema: {
+        domain: z.string().optional().describe("Apex billing domain; defaults to the domain bound in .sakupa/site.json."),
+        plan: planEnum.optional().describe("Target monthly plan."),
+        cancelRenewal: z.boolean().optional().describe(
+          "true: cancel renewal (hosting runs to the end of the paid month, then stops). false: re-enable renewal."
+        ),
+        confirm: z.boolean().optional().describe("User saw the consequences and explicitly confirmed.")
+      }
+    },
+    async (args) => {
+      try {
+        const site = requireSiteFile(ctx);
+        const domain = args.domain ?? site.billingDomain;
+        if (!domain) {
+          throw new SakupaError(
+            "invalid_request",
+            "No domain given and this project has no bound billing domain. Pass domain explicitly."
+          );
+        }
+        const req = {
+          siteId: site.siteId,
+          ...args.plan !== void 0 ? { committedTier: args.plan } : {},
+          ...args.cancelRenewal !== void 0 ? { cancelRenewal: args.cancelRenewal } : {},
+          confirm: args.confirm === true
+        };
+        try {
+          const res = await ctx.client.setBillingPlan(domain, site.credential, req);
+          return textJson(
+            `Billing plan updated for ${res.apexDomain}.
+Consequences:
+${res.consequences.map((c) => `- ${c}`).join("\n")}
+Applied plan:`,
+            res
+          );
+        } catch (e) {
+          if (isSakupaError(e) && e.code === "confirmation_required") {
+            return text(
+              `Confirmation required before changing the billing plan \u2014 nothing was applied.
+
+${e.message}
+` + (e.details !== void 0 ? `${JSON.stringify(e.details, null, 2)}
+` : "") + "\nPlease show these consequences to the user and, after their explicit confirmation, re-run set_billing_plan with the same arguments plus confirm: true."
+            );
+          }
+          throw e;
+        }
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+  server.registerTool(
+    "downgrade_to_free",
+    {
+      description: "Move this paid custom-domain site back to free temporary mode. Takes effect at the next billing period boundary by default; immediateStopServing stops custom-domain serving now but never erases the already-paid month. Remember to also cancel the domain subscription (set_billing_plan cancelRenewal: true or manage_billing) if no other site uses it. The API returns the consequences first; confirm: true is required to apply.",
+      inputSchema: {
+        immediateStopServing: z.boolean().optional().describe(
+          "Also stop custom-domain serving immediately (does not remove current-cycle charges)."
+        ),
+        confirm: z.boolean().optional().describe("User saw the consequences and explicitly confirmed.")
+      }
+    },
+    async (args) => {
+      try {
+        const site = requireSiteFile(ctx);
+        try {
+          const res = await ctx.client.downgradeSite(site.siteId, site.credential, {
+            ...args.immediateStopServing !== void 0 ? { immediateStopServing: args.immediateStopServing } : {},
+            confirm: args.confirm === true
+          });
+          return text(
+            `Downgrade scheduled for site ${res.siteId}.
+Effective at: ${res.effectiveAt}
+Immediate stop-serving applied: ${res.immediateStopApplied ? "yes" : "no"}
+${res.message}
+
+After it takes effect the site becomes a free temporary site again (24h validity, free banner, free limits). If no other site uses this domain, also cancel its hosting subscription (set_billing_plan cancelRenewal: true or manage_billing).`
+          );
+        } catch (e) {
+          if (isSakupaError(e) && e.code === "confirmation_required") {
+            return text(
+              `Confirmation required before downgrading \u2014 nothing was applied.
+
+${e.message}
+` + (e.details !== void 0 ? `${JSON.stringify(e.details, null, 2)}
+` : "") + "\nPlease show these consequences to the user and, after their explicit confirmation, re-run downgrade_to_free with confirm: true."
+            );
+          }
+          throw e;
+        }
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+  server.registerTool(
+    "create_support_ticket",
+    {
+      description: "Create a Sakupa support ticket for billing, payment, refund review, domain verification, deployment, serving or other issues the MCP cannot solve automatically. Do not include secrets, credentials or card data in the description.",
+      inputSchema: {
+        category: ticketCategoryEnum,
+        subject: z.string().describe("Short subject line."),
+        description: z.string().describe("Problem description (no secrets, no card data)."),
+        contactEmail: z.string().optional().describe("Optional contact email for follow-up.")
+      }
+    },
+    async (args) => {
+      try {
+        const site = requireSiteFile(ctx);
+        const res = await ctx.client.createTicket(site.credential, {
+          siteId: site.siteId,
+          category: args.category,
+          subject: args.subject,
+          description: args.description,
+          ...args.contactEmail !== void 0 ? { contactEmail: args.contactEmail } : {}
+        });
+        return text(`Support ticket created: ${res.ticketId} (status: ${res.status}).`);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+  server.registerTool(
+    "report_bug",
+    {
+      description: "Prepare and submit a sanitized bug report when a Sakupa tool failed and the issue looks like a product bug. Only whitelisted structured diagnostics are sent (tool name, error code/message, site id, billing domain, deployment id, timestamps, client/MCP version, request id) \u2014 NEVER file contents, source code, secrets, .env values or credentials. Without confirmSubmit: true the exact payload is shown for user review and nothing is submitted.",
+      inputSchema: {
+        toolName: z.string().describe('The Sakupa tool that failed, e.g. "deploy_site".'),
+        errorCode: z.string().optional(),
+        errorMessage: z.string().optional().describe("Sanitized error message (no secrets)."),
+        requestId: z.string().optional(),
+        deploymentId: z.string().optional(),
+        severity: severityEnum.optional(),
+        description: z.string().optional().describe("What happened, in the user's words (no secrets)."),
+        confirmSubmit: z.boolean().optional().describe("User reviewed the report payload and approved submission.")
+      }
+    },
+    async (args) => {
+      try {
+        const site = readSiteFile(ctx.projectDir);
+        const diagnostics = {
+          toolName: args.toolName,
+          ...args.errorCode !== void 0 ? { errorCode: args.errorCode } : {},
+          ...args.errorMessage !== void 0 ? { sanitizedErrorMessage: args.errorMessage } : {},
+          ...site ? { siteId: site.siteId } : {},
+          ...site?.billingDomain ? { billingDomain: site.billingDomain } : {},
+          ...args.deploymentId !== void 0 ? { deploymentId: args.deploymentId } : {},
+          occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+          clientType: CLIENT_TYPE,
+          mcpVersion: MCP_VERSION,
+          ...args.requestId !== void 0 ? { requestId: args.requestId } : {}
+        };
+        const payload = {
+          ...site ? { siteId: site.siteId } : {},
+          ...args.severity !== void 0 ? { severity: args.severity } : {},
+          diagnostics,
+          ...args.description !== void 0 ? { description: args.description } : {}
+        };
+        if (args.confirmSubmit !== true) {
+          return textJson(
+            "Bug report prepared but NOT submitted. This is the exact payload that would be sent (structured diagnostics only \u2014 no file contents, source code or secrets). Please show it to the user; re-run report_bug with confirmSubmit: true to submit.",
+            payload
+          );
+        }
+        const res = await ctx.client.reportBug(payload, site?.credential);
+        return text(
+          `Bug report submitted. Ticket: ${res.ticketId}
+Summary: ${res.sanitizedSummary}`
+        );
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+}
+
+// src/transport.ts
+var FetchTransport = class {
+  baseUrl;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+  async request(req) {
+    let url = `${this.baseUrl}${req.path}`;
+    if (req.query && Object.keys(req.query).length > 0) {
+      url += `?${new URLSearchParams(req.query).toString()}`;
+    }
+    const headers = {
+      accept: "application/json",
+      ...req.body !== void 0 ? { "content-type": "application/json" } : {},
+      ...req.headers
+    };
+    const res = await fetch(url, {
+      method: req.method,
+      headers,
+      ...req.body !== void 0 ? { body: req.body } : {}
+    });
+    const text2 = await res.text();
+    const responseHeaders = {};
+    res.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    return {
+      status: res.status,
+      headers: responseHeaders,
+      ...text2.length > 0 ? { body: text2 } : {}
+    };
+  }
+  async upload(target, body) {
+    if (target.url.startsWith("memory://")) {
+      throw new Error(
+        `Upload target "${target.url}" is an in-process memory URL. memory:// targets only exist inside the in-process test harness and cannot be uploaded to over HTTP.`
+      );
+    }
+    const res = await fetch(target.url, {
+      method: target.method,
+      headers: target.headers,
+      body
+    });
+    if (!res.ok) {
+      const text2 = await res.text().catch(() => "");
+      throw new Error(
+        `Upload of "${target.path}" failed with HTTP ${res.status}${text2 ? `: ${text2.slice(0, 200)}` : ""}`
+      );
+    }
+  }
+};
+
+// src/server.ts
+var INSTRUCTIONS = `Sakupa publishes AI-made static websites. AI-made pages, live in seconds.
+
+Workflow:
+1. analyze_site \u2014 check whether this project has deployable static output. If a build is needed
+   (Vite/Vue/React/Svelte/Astro/Next static export/Nuxt generate), run the build LOCALLY first,
+   then re-run analyze_site.
+2. deploy_site \u2014 uploads ONLY the built static output. The first deploy creates a free temporary
+   site (public URL {shortId}.sakupa.com, valid 24 hours, free banner shown) and stores the
+   management credential in .sakupa/site.json. Deploying again updates the site and refreshes
+   its validity; refresh_site extends validity without uploading.
+3. For long-term use, subscribe the apex domain to a monthly hosting plan (subscribe_domain ->
+   Stripe-hosted checkout; water/personal/share/business, auto-upgrade when the site outgrows
+   its plan), then bind the custom domain (bind_domain): the billing subject is always the
+   registered apex domain and ownership is proven only by DNS control. billing_status,
+   set_billing_plan, manage_billing, downgrade_to_free and recover_domain_site manage the
+   paid lifecycle.
+
+Safety boundaries:
+- Static output only: no SSR, API routes, middleware, server actions, databases or online builds.
+- Never upload source projects, secrets, .env files, private keys, archives, videos or audio.
+- Payment card data is entered only on Stripe-hosted pages \u2014 never through the AI tool.
+- A subscription is payment state only; it never grants domain ownership or management rights.
+- The management credential lives only in .sakupa/site.json; never share or upload it.`;
+function createSakupaMcpServer(opts) {
+  const client = opts.client ?? new HttpApiClient(new FetchTransport(opts.apiBaseUrl));
+  const server = new McpServer(
+    { name: "sakupa", version: MCP_VERSION },
+    { instructions: INSTRUCTIONS }
+  );
+  registerTools(server, {
+    client,
+    projectDir: opts.projectDir,
+    apiBaseUrl: opts.apiBaseUrl
+  });
+  return server;
+}
+
+// src/bin.ts
+async function main() {
+  const apiBaseUrl = process.env["SAKUPA_API_URL"] ?? DEFAULT_API_BASE_URL;
+  const projectDir = process.env["SAKUPA_PROJECT_DIR"] ?? process.cwd();
+  const server = createSakupaMcpServer({ apiBaseUrl, projectDir });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(
+    `[sakupa-mcp] v${MCP_VERSION} connected (api: ${apiBaseUrl}, project: ${projectDir})`
+  );
+}
+main().catch((err) => {
+  console.error("[sakupa-mcp] fatal:", err instanceof Error ? err.message : err);
+  process.exit(1);
+});