@myna-sh/mcp 0.1.0

package/dist/main.js

@@ -0,0 +1,1118 @@
+// src/main.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/config.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// ../sdk/dist/chunk-VAS24QPJ.js
+var MynaApiError = class _MynaApiError extends Error {
+  /** HTTP status code. */
+  status;
+  /** Stable machine-readable error code (e.g. `VALIDATION_FAILED`). */
+  code;
+  /** RFC 9457 `type` URI. */
+  type;
+  /** Human-facing title. */
+  title;
+  /** Longer human-facing detail, when provided. */
+  detail;
+  /** Server request id for support/correlation. */
+  requestId;
+  /** Field-level validation errors, when present. */
+  fields;
+  /** The full parsed problem document (or a synthesized one). */
+  problem;
+  constructor(problem) {
+    super(problem.detail ?? problem.title ?? `Request failed (${problem.status})`);
+    this.name = "MynaApiError";
+    this.status = problem.status;
+    this.code = problem.code;
+    this.type = problem.type;
+    this.title = problem.title;
+    this.detail = problem.detail;
+    this.requestId = problem.requestId;
+    this.fields = problem.fields;
+    this.problem = problem;
+    Object.setPrototypeOf(this, _MynaApiError.prototype);
+  }
+  static is(value) {
+    return value instanceof _MynaApiError;
+  }
+};
+function isMynaApiError(value) {
+  return value instanceof MynaApiError;
+}
+function problemFromResponse(status, body, fallbackTitle) {
+  if (body && typeof body === "object" && "code" in body && "status" in body) {
+    return new MynaApiError(body);
+  }
+  const detail = body && typeof body === "object" && "error" in body && typeof body.error === "string" ? body.error : typeof body === "string" && body ? body : void 0;
+  return new MynaApiError({
+    type: "about:blank",
+    title: fallbackTitle,
+    status,
+    code: status >= 500 ? "INTERNAL" : "REQUEST_FAILED",
+    detail
+  });
+}
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
+var SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+function resolveFetch(custom) {
+  if (custom) return custom;
+  if (typeof globalThis.fetch === "function") return globalThis.fetch.bind(globalThis);
+  throw new Error("No fetch implementation available. Pass `fetch` to the Myna client.");
+}
+function buildQuery(query2) {
+  if (!query2) return "";
+  const params = new URLSearchParams();
+  const append = (key, value) => {
+    if (value === void 0 || value === null) return;
+    if (Array.isArray(value)) {
+      params.set(key, value.join(","));
+      return;
+    }
+    if (typeof value === "object") {
+      for (const [op, v] of Object.entries(value)) {
+        append(`${key}[${op}]`, v);
+      }
+      return;
+    }
+    params.set(key, String(value));
+  };
+  for (const [key, value] of Object.entries(query2)) append(key, value);
+  const qs = params.toString();
+  return qs ? `?${qs}` : "";
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(signal.reason ?? new Error("Aborted"));
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason ?? new Error("Aborted"));
+      },
+      { once: true }
+    );
+  });
+}
+var HttpClient = class {
+  baseUrl;
+  token;
+  fetchImpl;
+  defaultHeaders;
+  retry;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.token = options.token;
+    this.fetchImpl = resolveFetch(options.fetch);
+    this.defaultHeaders = options.headers ?? {};
+    this.retry = {
+      maxRetries: options.retry?.maxRetries ?? 3,
+      baseDelayMs: options.retry?.baseDelayMs ?? 200,
+      maxDelayMs: options.retry?.maxDelayMs ?? 5e3
+    };
+  }
+  /** Perform a request and unwrap the `{ data }` envelope. */
+  async request(method, path, options = {}) {
+    const raw = await this.requestRaw(method, path, options);
+    if (raw.status === 204 || raw.status === 304) return void 0;
+    const parsed = await raw.json().catch(() => void 0);
+    return parsed && "data" in parsed ? parsed.data : parsed;
+  }
+  /** Perform a request and return the full parsed body (envelope included). */
+  async requestEnvelope(method, path, options = {}) {
+    const raw = await this.requestRaw(method, path, options);
+    return await raw.json().catch(() => ({}));
+  }
+  /** Low-level request with retries; throws `MynaApiError` on non-2xx. */
+  async requestRaw(method, path, options = {}) {
+    const url = `${this.baseUrl}${path}${buildQuery(options.query)}`;
+    const headers = {
+      accept: "application/json",
+      ...this.defaultHeaders,
+      ...options.headers
+    };
+    const token = options.token ?? this.token;
+    if (token) headers.authorization = `Bearer ${token}`;
+    let payload;
+    if (options.body !== void 0) {
+      if (options.body instanceof Uint8Array || typeof options.body === "string") {
+        payload = options.body;
+      } else {
+        headers["content-type"] = "application/json";
+        payload = JSON.stringify(options.body);
+      }
+    }
+    if (options.idempotencyKey) headers["idempotency-key"] = options.idempotencyKey;
+    const idempotent = SAFE_METHODS.has(method.toUpperCase()) || Boolean(options.idempotencyKey);
+    const init = { method, headers };
+    if (payload !== void 0) init.body = payload;
+    if (options.signal) init.signal = options.signal;
+    let attempt = 0;
+    for (; ; ) {
+      let response;
+      try {
+        response = await this.fetchImpl(url, init);
+      } catch (error) {
+        if (idempotent && attempt < this.retry.maxRetries && !isAbort(error)) {
+          await sleep(this.backoff(attempt), options.signal);
+          attempt++;
+          continue;
+        }
+        throw error;
+      }
+      if (response.ok) return response;
+      if (idempotent && RETRYABLE_STATUS.has(response.status) && attempt < this.retry.maxRetries) {
+        const retryAfter = retryAfterMs(response);
+        await sleep(retryAfter ?? this.backoff(attempt), options.signal);
+        attempt++;
+        continue;
+      }
+      const body = await response.json().catch(() => void 0);
+      throw problemFromResponse(response.status, body, response.statusText || "Request failed");
+    }
+  }
+  backoff(attempt) {
+    const base = Math.min(this.retry.baseDelayMs * 2 ** attempt, this.retry.maxDelayMs);
+    return Math.round(base * (0.5 + Math.random() * 0.5));
+  }
+};
+function retryAfterMs(response) {
+  const header = response.headers.get("retry-after");
+  if (!header) return void 0;
+  const seconds = Number(header);
+  return Number.isFinite(seconds) ? seconds * 1e3 : void 0;
+}
+function isAbort(error) {
+  return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
+
+// ../sdk/dist/management.js
+import { createHash, randomUUID } from "crypto";
+import { readFile } from "fs/promises";
+import { basename } from "path";
+var DEFAULT_API_URL = "https://api.myna.sh";
+var ManagementClient = class {
+  http;
+  newIdempotencyKey;
+  fetchImpl;
+  constructor(options) {
+    if (!options.token) throw new Error("createManagementClient: `token` is required.");
+    this.newIdempotencyKey = options.idempotencyKey ?? (() => randomUUID());
+    this.fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+    this.http = new HttpClient({
+      baseUrl: `${(options.apiUrl ?? DEFAULT_API_URL).replace(/\/+$/, "")}/v1`,
+      token: options.token,
+      fetch: options.fetch,
+      retry: options.retry
+    });
+  }
+  // Convenience: idempotency key for a mutation.
+  idem() {
+    return this.newIdempotencyKey();
+  }
+  get(path, query2, signal) {
+    return this.http.request("GET", path, { query: query2, signal });
+  }
+  async page(path, opts = {}) {
+    const body = await this.http.requestEnvelope(
+      "GET",
+      path,
+      { query: { limit: opts.limit, cursor: opts.cursor }, signal: opts.signal }
+    );
+    return { data: body.data, nextCursor: body.pagination?.nextCursor ?? null };
+  }
+  mutate(method, path, body, query2) {
+    return this.http.request(method, path, { body, query: query2, idempotencyKey: this.idem() });
+  }
+  // --- Organizations --------------------------------------------------------
+  organizations = {
+    list: (signal) => this.get("/organizations", void 0, signal),
+    create: (body) => this.mutate("POST", "/organizations", body),
+    get: (organization, signal) => this.get(`/organizations/${enc(organization)}`, void 0, signal),
+    update: (organization, body) => this.mutate("PATCH", `/organizations/${enc(organization)}`, body),
+    delete: (organization) => this.mutate("DELETE", `/organizations/${enc(organization)}`),
+    export: (organization) => this.mutate("POST", `/organizations/${enc(organization)}/export`),
+    usage: (organization, signal) => this.get(`/organizations/${enc(organization)}/usage`, void 0, signal)
+  };
+  // --- Members & invitations ------------------------------------------------
+  members = {
+    list: (organization, signal) => this.get(`/organizations/${enc(organization)}/members`, void 0, signal),
+    update: (organization, user, body) => this.mutate("PATCH", `/organizations/${enc(organization)}/members/${enc(user)}`, body),
+    remove: (organization, user) => this.mutate("DELETE", `/organizations/${enc(organization)}/members/${enc(user)}`)
+  };
+  invitations = {
+    list: (organization, signal) => this.get(`/organizations/${enc(organization)}/invitations`, void 0, signal),
+    create: (organization, body) => this.mutate("POST", `/organizations/${enc(organization)}/invitations`, body),
+    revoke: (organization, invitation) => this.mutate("DELETE", `/organizations/${enc(organization)}/invitations/${enc(invitation)}`),
+    accept: (token) => this.mutate("POST", `/invitations/${enc(token)}/accept`)
+  };
+  // --- Projects -------------------------------------------------------------
+  projects = {
+    list: (organization, signal) => this.get(`/organizations/${enc(organization)}/projects`, void 0, signal),
+    create: (organization, body) => this.mutate("POST", `/organizations/${enc(organization)}/projects`, body),
+    get: (project, signal) => this.get(`/projects/${enc(project)}`, void 0, signal),
+    update: (project, body) => this.mutate("PATCH", `/projects/${enc(project)}`, body),
+    archive: (project) => this.mutate("POST", `/projects/${enc(project)}/archive`)
+  };
+  // --- Schema ---------------------------------------------------------------
+  schema = {
+    collections: (project, signal) => this.get(`/projects/${enc(project)}/collections`, void 0, signal),
+    collection: (project, key, signal) => this.get(`/projects/${enc(project)}/collections/${enc(key)}`, void 0, signal),
+    versions: (project, key, signal) => this.get(`/projects/${enc(project)}/collections/${enc(key)}/versions`, void 0, signal),
+    diff: (project, collections) => this.mutate("POST", `/projects/${enc(project)}/schema/diff`, { collections }),
+    push: (project, collections, opts = {}) => this.mutate("POST", `/projects/${enc(project)}/schema/push`, {
+      collections,
+      allowDestructive: opts.allowDestructive ?? false,
+      changeSummary: opts.changeSummary
+    })
+  };
+  // --- Entries & revisions --------------------------------------------------
+  entries = {
+    list: (project, opts = {}) => this.page(
+      `/projects/${enc(project)}/entries` + query({ collection: opts.collection, status: opts.status }),
+      opts
+    ),
+    create: (project, body) => this.mutate("POST", `/projects/${enc(project)}/entries`, body),
+    get: (project, entry, signal) => this.get(`/projects/${enc(project)}/entries/${enc(entry)}`, void 0, signal),
+    update: (project, entry, body) => this.mutate("PATCH", `/projects/${enc(project)}/entries/${enc(entry)}`, body),
+    delete: (project, entry, changeSetId) => this.mutate("DELETE", `/projects/${enc(project)}/entries/${enc(entry)}`, void 0, { changeSetId }),
+    unpublish: (project, entry, changeSetId) => this.mutate("POST", `/projects/${enc(project)}/entries/${enc(entry)}/unpublish`, void 0, { changeSetId }),
+    restore: (project, entry) => this.mutate("POST", `/projects/${enc(project)}/entries/${enc(entry)}/restore`),
+    revisions: (project, entry, signal) => this.get(`/projects/${enc(project)}/entries/${enc(entry)}/revisions`, void 0, signal),
+    revision: (project, entry, revision, signal) => this.get(`/projects/${enc(project)}/entries/${enc(entry)}/revisions/${enc(revision)}`, void 0, signal),
+    restoreRevision: (project, entry, revision) => this.mutate(
+      "POST",
+      `/projects/${enc(project)}/entries/${enc(entry)}/revisions/${enc(revision)}/restore`
+    )
+  };
+  // --- Change sets ----------------------------------------------------------
+  changeSets = {
+    list: (project, opts = {}) => this.page(`/projects/${enc(project)}/change-sets` + query({ status: opts.status }), opts),
+    create: (project, body) => this.mutate("POST", `/projects/${enc(project)}/change-sets`, body),
+    get: (project, changeSet, signal) => this.get(`/projects/${enc(project)}/change-sets/${enc(changeSet)}`, void 0, signal),
+    update: (project, changeSet, body) => this.mutate("PATCH", `/projects/${enc(project)}/change-sets/${enc(changeSet)}`, body),
+    validate: (project, changeSet) => this.mutate("POST", `/projects/${enc(project)}/change-sets/${enc(changeSet)}/validate`),
+    publish: (project, changeSet) => this.mutate("POST", `/projects/${enc(project)}/change-sets/${enc(changeSet)}/publish`, { confirm: true }),
+    close: (project, changeSet) => this.mutate("POST", `/projects/${enc(project)}/change-sets/${enc(changeSet)}/close`)
+  };
+  // --- Previews -------------------------------------------------------------
+  previews = {
+    create: (project, body) => this.mutate("POST", `/projects/${enc(project)}/previews`, body),
+    list: (project, signal) => this.get(`/projects/${enc(project)}/previews`, void 0, signal),
+    revoke: (project, preview) => this.mutate("DELETE", `/projects/${enc(project)}/previews/${enc(preview)}`)
+  };
+  // --- Assets ---------------------------------------------------------------
+  assets = {
+    createUpload: (project, body) => this.mutate("POST", `/projects/${enc(project)}/assets/uploads`, body),
+    completeUpload: (project, upload) => this.mutate("POST", `/projects/${enc(project)}/assets/uploads/${enc(upload)}/complete`).then(
+      (r) => r.asset
+    ),
+    list: (project, opts = {}) => this.page(`/projects/${enc(project)}/assets`, opts),
+    get: (project, asset, signal) => this.get(`/projects/${enc(project)}/assets/${enc(asset)}`, void 0, signal),
+    usage: (project, asset, signal) => this.get(`/projects/${enc(project)}/assets/${enc(asset)}`, { usage: "true" }, signal),
+    update: (project, asset, body) => this.mutate("PATCH", `/projects/${enc(project)}/assets/${enc(asset)}`, body),
+    delete: (project, asset) => this.mutate("DELETE", `/projects/${enc(project)}/assets/${enc(asset)}`),
+    /** Full presigned upload flow: create → PUT bytes → complete. */
+    upload: (project, input, meta = {}) => this.uploadAsset(project, input, meta)
+  };
+  // --- API keys -------------------------------------------------------------
+  apiKeys = {
+    listForOrganization: (organization, signal) => this.get(`/organizations/${enc(organization)}/api-keys`, void 0, signal),
+    createForOrganization: (organization, body) => this.mutate("POST", `/organizations/${enc(organization)}/api-keys`, body),
+    revokeForOrganization: (organization, key) => this.mutate("DELETE", `/organizations/${enc(organization)}/api-keys/${enc(key)}`),
+    listForProject: (project, signal) => this.get(`/projects/${enc(project)}/api-keys`, void 0, signal),
+    createForProject: (project, body) => this.mutate("POST", `/projects/${enc(project)}/api-keys`, body),
+    revokeForProject: (project, key) => this.mutate("DELETE", `/projects/${enc(project)}/api-keys/${enc(key)}`)
+  };
+  // --- Webhooks -------------------------------------------------------------
+  webhooks = {
+    list: (project, signal) => this.get(`/projects/${enc(project)}/webhooks`, void 0, signal),
+    create: (project, body) => this.mutate("POST", `/projects/${enc(project)}/webhooks`, body),
+    update: (project, webhook, body) => this.mutate("PATCH", `/projects/${enc(project)}/webhooks/${enc(webhook)}`, body),
+    delete: (project, webhook) => this.mutate("DELETE", `/projects/${enc(project)}/webhooks/${enc(webhook)}`),
+    deliveries: (project, webhook, signal) => this.get(`/projects/${enc(project)}/webhooks/${enc(webhook)}/deliveries`, void 0, signal),
+    retry: (project, webhook, delivery) => this.mutate("POST", `/projects/${enc(project)}/webhooks/${enc(webhook)}/deliveries/${enc(delivery)}/retry`)
+  };
+  // --- Activity -------------------------------------------------------------
+  activity(project, opts = {}) {
+    return this.page(
+      `/projects/${enc(project)}/activity` + query({
+        actorType: opts.actorType,
+        action: opts.action,
+        targetType: opts.targetType,
+        from: opts.from,
+        to: opts.to
+      }),
+      opts
+    );
+  }
+  // --- Billing --------------------------------------------------------------
+  billing = {
+    status: (organization, signal) => this.get(`/organizations/${enc(organization)}/billing`, void 0, signal),
+    checkout: (organization, body) => this.mutate("POST", `/organizations/${enc(organization)}/billing/checkout`, body),
+    portal: (organization) => this.mutate("POST", `/organizations/${enc(organization)}/billing/portal`)
+  };
+  // --- Upload helper --------------------------------------------------------
+  async uploadAsset(project, input, meta) {
+    const { bytes, filename } = await readInput(input, meta.filename);
+    const contentType = meta.contentType ?? guessContentType(filename);
+    const checksum = createHash("md5").update(bytes).digest("hex");
+    const upload = await this.assets.createUpload(project, {
+      filename,
+      contentType,
+      byteSize: meta.byteSize ?? bytes.byteLength,
+      checksum
+    });
+    const put = await this.fetchImpl(upload.url, {
+      method: upload.method,
+      headers: upload.headers,
+      body: bytes
+    });
+    if (!put.ok) {
+      throw new Error(`Asset upload PUT failed with status ${put.status}.`);
+    }
+    return this.assets.completeUpload(project, upload.uploadId);
+  }
+};
+async function readInput(input, filenameOverride) {
+  if (typeof input === "string") {
+    const bytes2 = await readFile(input);
+    return { bytes: new Uint8Array(bytes2), filename: filenameOverride ?? basename(input) };
+  }
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  return { bytes, filename: filenameOverride ?? "upload.bin" };
+}
+var CONTENT_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  pdf: "application/pdf",
+  json: "application/json",
+  txt: "text/plain",
+  md: "text/markdown",
+  csv: "text/csv",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav"
+};
+function guessContentType(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+  return CONTENT_TYPES[ext] ?? "application/octet-stream";
+}
+function enc(segment) {
+  return encodeURIComponent(segment);
+}
+function query(params) {
+  const entries = Object.entries(params).filter(([, v]) => v !== void 0 && v !== "");
+  if (entries.length === 0) return "";
+  return "?" + entries.map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+}
+function createManagementClient(options) {
+  return new ManagementClient(options);
+}
+
+// src/config.ts
+var DEFAULT_API_URL2 = "https://api.myna.sh";
+var ProjectRegistry = class {
+  constructor(env = process.env) {
+    this.env = env;
+    this.file = loadConfigFile(env);
+  }
+  env;
+  file;
+  clients = /* @__PURE__ */ new Map();
+  get defaultApiUrl() {
+    return this.env.MYNA_API_URL ?? this.file.apiUrl ?? DEFAULT_API_URL2;
+  }
+  get defaultToken() {
+    return this.env.MYNA_TOKEN ?? this.file.token;
+  }
+  /** The named-project key used when a call omits `project`. */
+  defaultProjectName() {
+    return this.file.default ?? (this.env.MYNA_PROJECT ? "__env" : void 0);
+  }
+  /** All configured named projects (env default included). */
+  list() {
+    const out = [];
+    if (this.env.MYNA_PROJECT) {
+      out.push({ name: "__env", project: this.env.MYNA_PROJECT, organization: this.env.MYNA_ORGANIZATION });
+    }
+    for (const [name, cfg] of Object.entries(this.file.projects ?? {})) {
+      out.push({ name, project: cfg.project, organization: cfg.organization });
+    }
+    return out;
+  }
+  /** Resolve a project reference: an explicit id/slug, a named config, or the default. */
+  resolve(ref) {
+    if (ref && this.file.projects?.[ref]) {
+      const cfg = this.file.projects[ref];
+      return {
+        project: cfg.project,
+        organization: cfg.organization,
+        apiUrl: cfg.apiUrl ?? this.defaultApiUrl,
+        token: cfg.token ?? this.defaultToken
+      };
+    }
+    if ((!ref || ref === "__env") && this.env.MYNA_PROJECT) {
+      return {
+        project: ref && ref !== "__env" ? ref : this.env.MYNA_PROJECT,
+        organization: this.env.MYNA_ORGANIZATION,
+        apiUrl: this.defaultApiUrl,
+        token: this.defaultToken
+      };
+    }
+    if (!ref && this.file.default && this.file.projects?.[this.file.default]) {
+      return this.resolve(this.file.default);
+    }
+    if (!ref) {
+      throw new Error("No project specified and no default is configured (set MYNA_PROJECT or configure a default).");
+    }
+    return { project: ref, organization: this.env.MYNA_ORGANIZATION, apiUrl: this.defaultApiUrl, token: this.defaultToken };
+  }
+  /** A management client bound to the resolved project's API + token. */
+  clientFor(ref) {
+    const resolved = this.resolve(ref);
+    if (!resolved.token) {
+      throw new Error("No credential available. Set MYNA_TOKEN or configure a token for the project.");
+    }
+    const cacheKey = `${resolved.apiUrl}::${resolved.token}`;
+    let client = this.clients.get(cacheKey);
+    if (!client) {
+      client = createManagementClient({ token: resolved.token, apiUrl: resolved.apiUrl });
+      this.clients.set(cacheKey, client);
+    }
+    return { client, project: resolved.project, organization: resolved.organization };
+  }
+  /** Resolve an organization for org-scoped calls. */
+  organizationFor(ref, organizationOverride) {
+    const resolved = this.resolve(ref);
+    const org = organizationOverride ?? resolved.organization;
+    if (!org) throw new Error("No organization specified. Provide `organization` or configure one for the project.");
+    return org;
+  }
+};
+function loadConfigFile(env) {
+  const explicit = env.MYNA_MCP_CONFIG;
+  const candidates = [explicit, join(env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "myna", "mcp.json")].filter(
+    (v) => Boolean(v)
+  );
+  for (const path of candidates) {
+    try {
+      return JSON.parse(readFileSync(path, "utf8"));
+    } catch {
+    }
+  }
+  return {};
+}
+
+// src/tools.ts
+import { z } from "zod";
+function ok(text, structured) {
+  return {
+    content: [{ type: "text", text }],
+    structuredContent: structured
+  };
+}
+function fail(error) {
+  const message = isMynaApiError(error) ? `${error.code}: ${error.detail ?? error.title}` : error instanceof Error ? error.message : String(error);
+  return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+}
+async function resolveEntryId(client, project, ref) {
+  if (ref.startsWith("ent_") && !ref.includes("/")) return ref;
+  const [collection, slug] = ref.includes("/") ? ref.split("/", 2) : [void 0, ref];
+  if (!collection) throw new Error(`Provide the entry as "<collection>/<slug>" or an ent_ id (got "${ref}").`);
+  let cursor;
+  for (let i = 0; i < 50; i++) {
+    const page = await client.entries.list(project, { collection, limit: 100, cursor });
+    const match = page.data.find((e) => e.slug === slug || e.id === slug);
+    if (match) return match.id;
+    if (!page.nextCursor) break;
+    cursor = page.nextCursor;
+  }
+  throw new Error(`Entry not found: ${ref}`);
+}
+var projectArg = { project: z.string().optional().describe("Project id, slug, or configured name. Omit to use the default.") };
+function registerTools(server, registry) {
+  server.registerTool(
+    "myna_list_projects",
+    {
+      title: "List projects",
+      description: "List projects in an organization.",
+      inputSchema: {
+        organization: z.string().optional().describe("Organization id or slug. Omit to use the default."),
+        ...projectArg
+      },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client } = registry.clientFor(args.project);
+        const org = registry.organizationFor(args.project, args.organization);
+        const projects = await client.projects.list(org);
+        return ok(`${projects.length} project(s) in ${org}.`, { projects });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_get_project",
+    {
+      title: "Get project",
+      description: "Fetch a single project's details.",
+      inputSchema: { ...projectArg },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const result = await client.projects.get(project);
+        return ok(`Project ${result.name} (${result.slug}).`, { project: result });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_list_collections",
+    {
+      title: "List collections",
+      description: "List the deployed collections in a project.",
+      inputSchema: { ...projectArg },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const collections = await client.schema.collections(project);
+        return ok(`${collections.length} collection(s).`, { collections });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_get_collection_schema",
+    {
+      title: "Get collection schema",
+      description: "Fetch the latest canonical schema for a collection.",
+      inputSchema: { ...projectArg, collection: z.string().describe("Collection key.") },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const versions = await client.schema.versions(project, args.collection);
+        const latest = versions[0];
+        if (!latest) throw new Error(`Collection ${args.collection} has no versions.`);
+        return ok(`${args.collection} schema v${latest.version}.`, { version: latest.version, schema: latest.schemaJson });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_list_entries",
+    {
+      title: "List entries",
+      description: "List entries in a collection.",
+      inputSchema: {
+        ...projectArg,
+        collection: z.string().describe("Collection key."),
+        status: z.enum(["draft", "published", "changed", "unpublished", "deleted"]).optional(),
+        limit: z.number().int().min(1).max(100).optional(),
+        cursor: z.string().optional()
+      },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const page = await client.entries.list(project, {
+          collection: args.collection,
+          status: args.status,
+          limit: args.limit ?? 25,
+          cursor: args.cursor
+        });
+        return ok(`${page.data.length} entr(y/ies).`, { entries: page.data, nextCursor: page.nextCursor });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_get_entry",
+    {
+      title: "Get entry",
+      description: 'Fetch one entry by "<collection>/<slug>" or entry id.',
+      inputSchema: { ...projectArg, entry: z.string().describe("collection/slug or ent_ id.") },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const id = await resolveEntryId(client, project, args.entry);
+        const entry = await client.entries.get(project, id);
+        return ok(`Entry ${entry.id} (${entry.status}).`, { entry });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_create_change_set",
+    {
+      title: "Create change set",
+      description: "Open a new change set to group entry and asset operations.",
+      inputSchema: {
+        ...projectArg,
+        title: z.string().min(1).max(200),
+        description: z.string().max(2e3).optional()
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const cs = await client.changeSets.create(project, { title: args.title, description: args.description });
+        return ok(`Created change set ${cs.id}.`, { changeSet: cs });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_get_change_set",
+    {
+      title: "Get change set",
+      description: "Fetch a change set and its items.",
+      inputSchema: { ...projectArg, changeSet: z.string().describe("Change set id (chs_).") },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const cs = await client.changeSets.get(project, args.changeSet);
+        return ok(`Change set ${cs.id} (${cs.status}), ${cs.items.length} item(s).`, { changeSet: cs });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_create_entry",
+    {
+      title: "Create entry",
+      description: "Create a draft entry. Does not publish.",
+      inputSchema: {
+        ...projectArg,
+        collection: z.string(),
+        data: z.record(z.string(), z.unknown()).describe("Field values."),
+        slug: z.string().optional(),
+        changeSet: z.string().optional().describe("Attach to an existing change set (chs_)."),
+        changeSummary: z.string().max(500).optional()
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const entry = await client.entries.create(project, {
+          collection: args.collection,
+          data: args.data,
+          slug: args.slug,
+          changeSetId: args.changeSet,
+          changeSummary: args.changeSummary
+        });
+        return ok(`Created entry ${entry.id} (${entry.status}).`, { entry });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_update_entry",
+    {
+      title: "Update entry",
+      description: "Update a draft entry. Does not publish.",
+      inputSchema: {
+        ...projectArg,
+        entry: z.string().describe("collection/slug or ent_ id."),
+        data: z.record(z.string(), z.unknown()).optional(),
+        slug: z.string().optional(),
+        expectedRevisionId: z.string().optional().describe("Optimistic concurrency guard."),
+        changeSet: z.string().optional(),
+        changeSummary: z.string().max(500).optional()
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const id = await resolveEntryId(client, project, args.entry);
+        const entry = await client.entries.update(project, id, {
+          data: args.data,
+          slug: args.slug,
+          expectedRevisionId: args.expectedRevisionId,
+          changeSetId: args.changeSet,
+          changeSummary: args.changeSummary
+        });
+        return ok(`Updated entry ${entry.id} (${entry.status}).`, { entry });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_delete_entry",
+    {
+      title: "Delete entry",
+      description: "Stage an entry deletion on a change set. Requires confirm=true. Takes effect only on publish.",
+      inputSchema: {
+        ...projectArg,
+        entry: z.string(),
+        changeSet: z.string().optional(),
+        confirm: z.literal(true).describe("Must be true to proceed.")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const id = await resolveEntryId(client, project, args.entry);
+        const result = await client.entries.delete(project, id, args.changeSet);
+        return ok(`Staged delete of ${id} on ${result.changeSetId}.`, result);
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_upload_asset",
+    {
+      title: "Upload asset",
+      description: "Upload an asset from base64 bytes or a local file path via the presigned flow.",
+      inputSchema: {
+        ...projectArg,
+        filename: z.string().describe("Display filename, e.g. cover.png."),
+        base64: z.string().optional().describe("Base64-encoded file bytes."),
+        path: z.string().optional().describe("Local filesystem path (stdio hosts only)."),
+        contentType: z.string().optional()
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        if (!args.base64 && !args.path) throw new Error("Provide either `base64` or `path`.");
+        const input = args.base64 ? new Uint8Array(Buffer.from(args.base64, "base64")) : args.path;
+        const asset = await client.assets.upload(project, input, {
+          filename: args.filename,
+          contentType: args.contentType
+        });
+        return ok(`Uploaded ${asset.displayFilename} (${asset.id}).`, { asset });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_validate_change_set",
+    {
+      title: "Validate change set",
+      description: "Validate every changed resource in a change set against the deployed schemas.",
+      inputSchema: { ...projectArg, changeSet: z.string() },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const result = await client.changeSets.validate(project, args.changeSet);
+        return ok(result.valid ? "Change set is valid." : `Invalid: ${result.errors.length} error(s).`, result);
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_create_preview",
+    {
+      title: "Create preview",
+      description: "Create one preview URL for a change set (or entry). Never publishes.",
+      inputSchema: {
+        ...projectArg,
+        changeSet: z.string().optional().describe("Change set id (chs_)."),
+        entry: z.string().optional().describe("Entry id (ent_)."),
+        expiresInSeconds: z.number().int().min(60).max(604800).optional()
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        if (Boolean(args.changeSet) === Boolean(args.entry)) {
+          throw new Error("Provide exactly one of `changeSet` or `entry`.");
+        }
+        const { client, project } = registry.clientFor(args.project);
+        const preview = await client.previews.create(project, {
+          changeSetId: args.changeSet,
+          entryId: args.entry,
+          expiresInSeconds: args.expiresInSeconds
+        });
+        return ok(`Preview: ${preview.url}`, { preview });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_publish_change_set",
+    {
+      title: "Publish change set",
+      description: "Atomically publish a change set. Requires confirm=true and content:publish scope.",
+      inputSchema: { ...projectArg, changeSet: z.string(), confirm: z.literal(true).describe("Must be true.") },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const result = await client.changeSets.publish(project, args.changeSet);
+        return ok(`Published ${result.publishedEntryIds.length} entr(y/ies).`, result);
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_get_entry_revisions",
+    {
+      title: "Get entry revisions",
+      description: "List the immutable revisions of an entry.",
+      inputSchema: { ...projectArg, entry: z.string() },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const id = await resolveEntryId(client, project, args.entry);
+        const revisions = await client.entries.revisions(project, id);
+        return ok(`${revisions.length} revision(s).`, { revisions });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_restore_revision",
+    {
+      title: "Restore revision",
+      description: "Restore a historical revision into a new draft revision. Requires confirm=true.",
+      inputSchema: {
+        ...projectArg,
+        entry: z.string(),
+        revision: z.string().describe("Revision id (rev_)."),
+        confirm: z.literal(true).describe("Must be true.")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const id = await resolveEntryId(client, project, args.entry);
+        const result = await client.entries.restoreRevision(project, id, args.revision);
+        return ok(`Restored into ${result.revision.id}.`, result);
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+}
+
+// src/resources.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function registerResources(server, registry) {
+  const json = (uri, value) => ({
+    contents: [{ uri, mimeType: "application/json", text: JSON.stringify(value, null, 2) }]
+  });
+  server.registerResource(
+    "projects",
+    "myna://projects",
+    { title: "Projects", description: "Projects in the default organization.", mimeType: "application/json" },
+    async (uri) => {
+      const { client } = registry.clientFor();
+      const org = registry.organizationFor();
+      const projects = await client.projects.list(org);
+      return json(uri.href, { organization: org, projects });
+    }
+  );
+  server.registerResource(
+    "collections",
+    new ResourceTemplate("myna://{project}/collections", { list: void 0 }),
+    { title: "Collections", description: "Deployed collections for a project.", mimeType: "application/json" },
+    async (uri, variables) => {
+      const project = String(variables.project);
+      const { client, project: ref } = registry.clientFor(project);
+      const collections = await client.schema.collections(ref);
+      return json(uri.href, { project: ref, collections });
+    }
+  );
+  server.registerResource(
+    "collection-schema",
+    new ResourceTemplate("myna://{project}/collection/{key}", { list: void 0 }),
+    { title: "Collection schema", description: "Latest canonical schema for a collection.", mimeType: "application/json" },
+    async (uri, variables) => {
+      const { client, project } = registry.clientFor(String(variables.project));
+      const versions = await client.schema.versions(project, String(variables.key));
+      const latest = versions[0];
+      return json(uri.href, { collection: String(variables.key), version: latest?.version ?? null, schema: latest?.schemaJson ?? null });
+    }
+  );
+  server.registerResource(
+    "entry",
+    new ResourceTemplate("myna://{project}/entry/{entry}", { list: void 0 }),
+    { title: "Entry", description: "An entry's current representation.", mimeType: "application/json" },
+    async (uri, variables) => {
+      const { client, project } = registry.clientFor(String(variables.project));
+      const entry = await client.entries.get(project, String(variables.entry));
+      return json(uri.href, { entry });
+    }
+  );
+  server.registerResource(
+    "entry-revisions",
+    new ResourceTemplate("myna://{project}/entry/{entry}/revisions", { list: void 0 }),
+    { title: "Entry revisions", description: "Immutable revisions for an entry.", mimeType: "application/json" },
+    async (uri, variables) => {
+      const { client, project } = registry.clientFor(String(variables.project));
+      const revisions = await client.entries.revisions(project, String(variables.entry));
+      return json(uri.href, { entry: String(variables.entry), revisions });
+    }
+  );
+  server.registerResource(
+    "change-set-validation",
+    new ResourceTemplate("myna://{project}/change-set/{changeSet}/validation", { list: void 0 }),
+    { title: "Change-set validation", description: "Validation result for a change set.", mimeType: "application/json" },
+    async (uri, variables) => {
+      const { client, project } = registry.clientFor(String(variables.project));
+      const result = await client.changeSets.validate(project, String(variables.changeSet));
+      return json(uri.href, result);
+    }
+  );
+}
+
+// src/server.ts
+var SERVER_NAME = "myna";
+var SERVER_VERSION = "0.1.0";
+function createServer() {
+  return createServerForRegistry(new ProjectRegistry());
+}
+function createServerForRegistry(registry) {
+  const server = new McpServer2(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    {
+      capabilities: { tools: {}, resources: {} },
+      instructions: "Myna MCP server: manage content, schemas, assets, change sets, and previews. The primary flow is: create a change set, apply entry/asset operations, validate, then create one preview URL. Publishing is a separate, confirmation-gated action."
+    }
+  );
+  registerTools(server, registry);
+  registerResources(server, registry);
+  return server;
+}
+
+// src/http.ts
+import { createServer as createHttpServer } from "http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf8");
+      if (!raw) return resolve(void 0);
+      try {
+        resolve(JSON.parse(raw));
+      } catch (error) {
+        reject(error);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function bearer(req) {
+  const header = req.headers.authorization;
+  return header?.startsWith("Bearer ") ? header.slice(7).trim() : void 0;
+}
+async function runHttp(options) {
+  const registry = new ProjectRegistry();
+  const path = options.path ?? "/mcp";
+  const httpServer = createHttpServer((req, res) => {
+    void handle(req, res).catch((error) => {
+      if (!res.headersSent) res.writeHead(500, { "content-type": "application/json" });
+      res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32603, message: String(error) }, id: null }));
+    });
+  });
+  async function handle(req, res) {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    if (url.pathname === "/health") {
+      res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true }));
+      return;
+    }
+    if (url.pathname !== path) {
+      res.writeHead(404, { "content-type": "application/json" }).end(JSON.stringify({ error: "not found" }));
+      return;
+    }
+    if (options.authToken && bearer(req) !== options.authToken) {
+      res.writeHead(401, { "content-type": "application/json" }).end(JSON.stringify({ error: "unauthorized" }));
+      return;
+    }
+    if (req.method !== "POST") {
+      res.writeHead(405, { "content-type": "application/json", allow: "POST" }).end(
+        JSON.stringify({ jsonrpc: "2.0", error: { code: -32e3, message: "Method not allowed." }, id: null })
+      );
+      return;
+    }
+    const body = await readBody(req);
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+    const server = createServerForRegistry(registry);
+    res.on("close", () => {
+      void transport.close();
+      void server.close();
+    });
+    await server.connect(transport);
+    await transport.handleRequest(req, res, body);
+  }
+  await new Promise((resolve) => httpServer.listen(options.port, resolve));
+  process.stderr.write(`myna-mcp: streamable HTTP transport listening on :${options.port}${path}
+`);
+}
+
+// src/main.ts
+async function main(argv = process.argv.slice(2)) {
+  const useHttp = argv.includes("--http") || process.env.MYNA_MCP_TRANSPORT === "http";
+  if (useHttp) {
+    const port = Number(process.env.MYNA_MCP_PORT ?? process.env.PORT ?? 3333);
+    const authToken = process.env.MYNA_MCP_TOKEN ?? process.env.MYNA_TOKEN;
+    await runHttp({ port, authToken });
+    return;
+  }
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stderr.write("myna-mcp: stdio transport ready\n");
+}
+export {
+  createServer,
+  main,
+  runHttp
+};
+//# sourceMappingURL=main.js.map