@myna-sh/cli 0.1.0

package/dist/main.js

@@ -0,0 +1,2181 @@
+// src/main.ts
+import { Command, CommanderError } from "commander";
+
+// ../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((resolve3, reject) => {
+    if (signal?.aborted) return reject(signal.reason ?? new Error("Aborted"));
+    const timer = setTimeout(resolve3, 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";
+function generateTypes(collections) {
+  const sorted = [...collections].sort((a, b) => a.name.localeCompare(b.name));
+  const blocks = [];
+  for (const collection of sorted) {
+    blocks.push(renderInterface(collection));
+  }
+  const registry = sorted.map((c) => `  ${JSON.stringify(c.name)}: ${pascal(c.name)};`).join("\n");
+  const header = [
+    "// Generated by `myna types generate`. Do not edit by hand.",
+    "// This file is safe to commit and regenerate.",
+    ""
+  ].join("\n");
+  return `${header}${blocks.join("\n\n")}
+
+export interface MynaCollections {
+${registry}
+}
+`;
+}
+function renderInterface(collection) {
+  const name = pascal(collection.name);
+  const lines = collection.fields.map((f) => renderField(f, 1));
+  const label = collection.label ? ` ${collection.label}` : "";
+  return `/**${label} (${collection.kind}) */
+export interface ${name} {
+${lines.join("\n")}
+}`;
+}
+function renderField(field, depth) {
+  const indent = "  ".repeat(depth);
+  const optional = field.required ? "" : "?";
+  const doc = field.description ? `${indent}/** ${escapeComment(field.description)} */
+` : "";
+  return `${doc}${indent}${safeKey(field.key)}${optional}: ${fieldType(field, depth)};`;
+}
+function fieldType(field, depth) {
+  switch (field.type) {
+    case "text":
+      return field.enum && field.enum.length > 0 ? field.enum.map((v) => JSON.stringify(v)).join(" | ") : "string";
+    case "slug":
+      return "string";
+    case "markdown":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "datetime":
+      return "string";
+    case "json":
+      return "JsonValue";
+    case "asset":
+      return field.multiple ? "string[]" : "string";
+    case "reference":
+      return field.multiple ? "string[]" : "string";
+    case "object":
+      return renderObject(field, depth);
+    case "list":
+      return `${listItemType(field.item, depth)}[]`;
+    default:
+      return "unknown";
+  }
+}
+function renderObject(field, depth) {
+  const lines = field.fields.map((f) => renderField(f, depth + 1));
+  const closingIndent = "  ".repeat(depth);
+  return `{
+${lines.join("\n")}
+${closingIndent}}`;
+}
+function listItemType(item, depth) {
+  switch (item.kind) {
+    case "text":
+      return item.enum && item.enum.length > 0 ? `(${item.enum.map((v) => JSON.stringify(v)).join(" | ")})` : "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "datetime":
+      return "string";
+    case "markdown":
+      return "string";
+    case "json":
+      return "JsonValue";
+    case "reference":
+      return "string";
+    case "asset":
+      return "string";
+    case "object": {
+      const lines = item.fields.map((f) => renderField(f, depth + 1));
+      const closingIndent = "  ".repeat(depth);
+      return `{
+${lines.join("\n")}
+${closingIndent}}`;
+    }
+    default:
+      return "unknown";
+  }
+}
+var JSON_VALUE = "export type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };";
+function generateTypesModule(collections) {
+  return `${JSON_VALUE}
+
+${generateTypes(collections)}`;
+}
+function pascal(key) {
+  return key.split(/[-_\s]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function safeKey(key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+function escapeComment(text) {
+  return text.replace(/\*\//g, "*\\/");
+}
+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
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync, rmSync } from "fs";
+import { homedir, platform } from "os";
+import { dirname, join, resolve } from "path";
+var DEFAULT_API_URL2 = "https://api.myna.sh";
+var KEYCHAIN_SERVICE = "sh.myna.cli";
+function configDir() {
+  const base = process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+  return join(base, "myna");
+}
+function configFile() {
+  return join(configDir(), "config.json");
+}
+function credentialsFile() {
+  return join(configDir(), "credentials.json");
+}
+function readUserConfig() {
+  try {
+    return JSON.parse(readFileSync(configFile(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeUserConfig(patch) {
+  const current = readUserConfig();
+  const next = { ...current, ...patch };
+  ensureDir(configDir());
+  writeFileSync(configFile(), JSON.stringify(next, null, 2) + "\n");
+  return next;
+}
+function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
+}
+function findLinkedProject(startDir = process.cwd()) {
+  let dir = resolve(startDir);
+  for (; ; ) {
+    const file = join(dir, ".myna", "project.json");
+    if (existsSync(file)) {
+      try {
+        const linked = JSON.parse(readFileSync(file, "utf8"));
+        return { linked, root: dir };
+      } catch {
+        return void 0;
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function writeLinkedProject(root, linked) {
+  const dir = join(root, ".myna");
+  ensureDir(dir);
+  writeFileSync(join(dir, "project.json"), JSON.stringify(linked, null, 2) + "\n");
+}
+function removeLinkedProject(root) {
+  const file = join(root, ".myna", "project.json");
+  if (existsSync(file)) {
+    rmSync(file);
+    return true;
+  }
+  return false;
+}
+function isMac() {
+  return platform() === "darwin";
+}
+function keychainAccount(apiUrl) {
+  return apiUrl.replace(/\/+$/, "");
+}
+function storeToken(apiUrl, token) {
+  const account = keychainAccount(apiUrl);
+  if (isMac()) {
+    try {
+      execFileSync(
+        "security",
+        ["add-generic-password", "-U", "-s", KEYCHAIN_SERVICE, "-a", account, "-w", token],
+        { stdio: "ignore" }
+      );
+      return "keychain";
+    } catch {
+    }
+  }
+  const file = credentialsFile();
+  const store = readCredentialFile();
+  store[account] = token;
+  ensureDir(configDir());
+  writeFileSync(file, JSON.stringify(store, null, 2) + "\n");
+  chmodSync(file, 384);
+  return "file";
+}
+function loadToken(apiUrl) {
+  const account = keychainAccount(apiUrl);
+  if (isMac()) {
+    try {
+      const out = execFileSync(
+        "security",
+        ["find-generic-password", "-s", KEYCHAIN_SERVICE, "-a", account, "-w"],
+        { stdio: ["ignore", "pipe", "ignore"] }
+      );
+      const token = out.toString("utf8").trim();
+      if (token) return token;
+    } catch {
+    }
+  }
+  return readCredentialFile()[account];
+}
+function clearToken(apiUrl) {
+  const account = keychainAccount(apiUrl);
+  if (isMac()) {
+    try {
+      execFileSync("security", ["delete-generic-password", "-s", KEYCHAIN_SERVICE, "-a", account], {
+        stdio: "ignore"
+      });
+    } catch {
+    }
+  }
+  const store = readCredentialFile();
+  if (account in store) {
+    delete store[account];
+    writeFileSync(credentialsFile(), JSON.stringify(store, null, 2) + "\n");
+    chmodSync(credentialsFile(), 384);
+  }
+}
+function readCredentialFile() {
+  try {
+    return JSON.parse(readFileSync(credentialsFile(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function resolveContext(flags) {
+  const link = findLinkedProject();
+  const user = readUserConfig();
+  const apiUrl = flags.apiUrl ?? process.env.MYNA_API_URL ?? link?.linked.apiUrl ?? user.apiUrl ?? DEFAULT_API_URL2;
+  const token = flags.token ?? process.env.MYNA_TOKEN ?? loadToken(apiUrl);
+  const project = flags.project ?? process.env.MYNA_PROJECT ?? link?.linked.project ?? user.defaultProject;
+  const organization = flags.organization ?? process.env.MYNA_ORGANIZATION ?? link?.linked.organization ?? user.defaultOrganization;
+  return {
+    apiUrl: apiUrl.replace(/\/+$/, ""),
+    token,
+    project,
+    organization,
+    json: Boolean(flags.json),
+    interactive: flags.interactive !== false && process.stdout.isTTY === true,
+    linked: link?.linked,
+    linkedRoot: link?.root
+  };
+}
+
+// src/output.ts
+var CLI_JSON_VERSION = 1;
+var UsageError = class extends Error {
+};
+var CliError = class extends Error {
+};
+var mode = { json: false };
+function setOutputMode(next) {
+  mode = next;
+}
+function diag(message) {
+  if (!mode.json) process.stderr.write(message + "\n");
+}
+function emit(value, human) {
+  if (mode.json) {
+    process.stdout.write(JSON.stringify({ version: CLI_JSON_VERSION, data: value }) + "\n");
+    return;
+  }
+  if (human) {
+    human();
+  } else {
+    process.stdout.write(prettyValue(value) + "\n");
+  }
+}
+function reportError(error) {
+  if (isMynaApiError(error)) {
+    const problem = {
+      code: error.code,
+      status: error.status,
+      title: error.title,
+      detail: error.detail,
+      requestId: error.requestId,
+      fields: error.fields
+    };
+    if (mode.json) {
+      process.stdout.write(JSON.stringify({ version: CLI_JSON_VERSION, error: problem }) + "\n");
+    } else {
+      process.stderr.write(`error: ${error.code} \u2014 ${error.detail ?? error.title}
+`);
+      for (const f of error.fields ?? []) {
+        process.stderr.write(`  \xB7 ${f.path}: ${f.message}
+`);
+      }
+      if (error.requestId) process.stderr.write(`  requestId: ${error.requestId}
+`);
+    }
+    return 1;
+  }
+  const usage = error instanceof UsageError;
+  const message = error instanceof Error ? error.message : String(error);
+  if (mode.json) {
+    process.stdout.write(
+      JSON.stringify({ version: CLI_JSON_VERSION, error: { code: usage ? "USAGE" : "ERROR", detail: message } }) + "\n"
+    );
+  } else {
+    process.stderr.write(`error: ${message}
+`);
+  }
+  return usage ? 2 : 1;
+}
+function table(rows, columns) {
+  if (rows.length === 0) {
+    process.stdout.write("(none)\n");
+    return;
+  }
+  const headers = columns.map((c) => c.header);
+  const cells = rows.map((r) => columns.map((c) => c.value(r) ?? ""));
+  const widths = headers.map((h, i) => Math.max(h.length, ...cells.map((row) => stripLen(row[i] ?? ""))));
+  const line = (values) => values.map((v, i) => pad(v, widths[i] ?? v.length)).join("  ").replace(/\s+$/, "");
+  process.stdout.write(line(headers) + "\n");
+  process.stdout.write(widths.map((w) => "\u2500".repeat(w)).join("  ") + "\n");
+  for (const row of cells) process.stdout.write(line(row) + "\n");
+}
+function keyValues(pairs) {
+  const width = Math.max(...pairs.map(([k]) => k.length));
+  for (const [k, v] of pairs) {
+    process.stdout.write(`${pad(k + ":", width + 1)}  ${v}
+`);
+  }
+}
+function pad(value, width) {
+  const len = stripLen(value);
+  return len >= width ? value : value + " ".repeat(width - len);
+}
+function stripLen(value) {
+  return value.length;
+}
+function prettyValue(value) {
+  if (typeof value === "string") return value;
+  return JSON.stringify(value, null, 2);
+}
+
+// src/client.ts
+function buildContext(flags) {
+  const resolved = resolveContext(flags);
+  let mgmt;
+  return {
+    ...resolved,
+    management() {
+      if (!resolved.token) {
+        throw new CliError("Not authenticated. Run `myna login` or pass --token / set MYNA_TOKEN.");
+      }
+      mgmt ??= createManagementClient({ token: resolved.token, apiUrl: resolved.apiUrl });
+      return mgmt;
+    },
+    requireProject() {
+      if (!resolved.project) {
+        throw new UsageError("No project selected. Pass --project, set MYNA_PROJECT, or run `myna link`.");
+      }
+      return resolved.project;
+    },
+    requireOrganization() {
+      if (!resolved.organization) {
+        throw new UsageError("No organization selected. Pass --organization or set a default with `myna organizations use`.");
+      }
+      return resolved.organization;
+    }
+  };
+}
+
+// src/runtime.ts
+function handle(fn) {
+  return async (...cbArgs) => {
+    const command = cbArgs[cbArgs.length - 1];
+    const ctx = buildContext(command.optsWithGlobals());
+    setOutputMode({ json: ctx.json });
+    try {
+      await fn(ctx, command.processedArgs, command.opts());
+    } catch (error) {
+      process.exitCode = reportError(error);
+    }
+  };
+}
+
+// src/util.ts
+import { execFile } from "child_process";
+import { readFileSync as readFileSync2 } from "fs";
+import { platform as platform2 } from "os";
+function parseData(input) {
+  if (!input) return {};
+  const raw = input.startsWith("@") ? readFileSync2(input.slice(1), "utf8") : input;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new UsageError(`Invalid JSON for --data: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new UsageError("--data must be a JSON object.");
+  }
+  return parsed;
+}
+function applySets(target, sets) {
+  if (!sets) return target;
+  for (const assignment of sets) {
+    const eq = assignment.indexOf("=");
+    if (eq === -1) throw new UsageError(`Invalid --set "${assignment}". Expected path=value.`);
+    const path = assignment.slice(0, eq);
+    const rawValue = assignment.slice(eq + 1);
+    let value;
+    try {
+      value = JSON.parse(rawValue);
+    } catch {
+      value = rawValue;
+    }
+    setPath(target, path.split("."), value);
+  }
+  return target;
+}
+function setPath(obj, parts, value) {
+  let cursor = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    if (typeof cursor[key] !== "object" || cursor[key] === null) cursor[key] = {};
+    cursor = cursor[key];
+  }
+  cursor[parts[parts.length - 1]] = value;
+}
+function openBrowser(url) {
+  const cmd = platform2() === "darwin" ? "open" : platform2() === "win32" ? "cmd" : "xdg-open";
+  const args = platform2() === "win32" ? ["/c", "start", "", url] : [url];
+  execFile(cmd, args, () => void 0);
+}
+function parseEntryRef(ref) {
+  if (ref.startsWith("ent_") && !ref.includes("/")) return { slugOrId: ref };
+  const slash = ref.indexOf("/");
+  if (slash === -1) return { slugOrId: ref };
+  return { collection: ref.slice(0, slash), slugOrId: ref.slice(slash + 1) };
+}
+async function resolveEntryId(mgmt, project, ref) {
+  const parsed = parseEntryRef(ref);
+  if (parsed.slugOrId.startsWith("ent_")) return parsed.slugOrId;
+  if (!parsed.collection) {
+    throw new UsageError(`Provide the entry as <collection>/<slug> or an ent_ id (got "${ref}").`);
+  }
+  let cursor;
+  for (let guard = 0; guard < 50; guard++) {
+    const page = await mgmt.entries.list(project, { collection: parsed.collection, limit: 100, cursor });
+    const match = page.data.find((e) => e.slug === parsed.slugOrId || e.id === parsed.slugOrId);
+    if (match) return match.id;
+    if (!page.nextCursor) break;
+    cursor = page.nextCursor;
+  }
+  throw new CliError(`Entry not found: ${ref}`);
+}
+
+// src/commands/auth.ts
+async function apiPost(apiUrl, path, body) {
+  const res = await fetch(`${apiUrl}/v1${path}`, {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: "application/json" },
+    body: JSON.stringify(body)
+  });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok) throw new CliError(json.detail ?? `Request failed (${res.status}).`);
+  return json.data;
+}
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+function registerAuth(program) {
+  program.command("login").description("Authenticate via the browser device-authorization flow").action(
+    handle(async (ctx) => {
+      const start = await apiPost(ctx.apiUrl, "/auth/device", {});
+      diag(`
+  To authenticate, open:
+    ${start.verificationUri}
+  and enter the code:  ${start.userCode}
+`);
+      if (ctx.interactive) openBrowser(start.verificationUri);
+      const deadline = Date.now() + start.expiresIn * 1e3;
+      let token;
+      while (Date.now() < deadline) {
+        await sleep2(Math.max(1, start.interval) * 1e3);
+        const poll = await apiPost(ctx.apiUrl, `/auth/device/${start.deviceCode}/token`, {
+          deviceCode: start.deviceCode
+        });
+        if (poll.status === "approved" && poll.token) {
+          token = poll.token;
+          break;
+        }
+        if (poll.status === "denied" || poll.status === "expired") {
+          throw new CliError(`Authorization ${poll.status}.`);
+        }
+      }
+      if (!token) throw new CliError("Device authorization timed out.");
+      const location = storeToken(ctx.apiUrl, token);
+      diag(`  Stored credential (${location}).`);
+      emit(
+        { ok: true, apiUrl: ctx.apiUrl, storage: location },
+        () => process.stdout.write(`Logged in to ${ctx.apiUrl}
+`)
+      );
+    })
+  );
+  program.command("logout").description("Remove the stored credential for the current API URL").action(
+    handle(async (ctx) => {
+      clearToken(ctx.apiUrl);
+      emit({ ok: true }, () => process.stdout.write(`Logged out of ${ctx.apiUrl}
+`));
+    })
+  );
+  program.command("whoami").description("Show the authenticated identity").action(
+    handle(async (ctx) => {
+      const token = ctx.token ?? loadToken(ctx.apiUrl);
+      if (!token) throw new CliError("Not authenticated. Run `myna login`.");
+      const account = await fetch(`${ctx.apiUrl}/v1/account`, {
+        headers: { authorization: `Bearer ${token}`, accept: "application/json" }
+      }).then(async (r) => r.ok ? (await r.json()).data.user : void 0).catch(() => void 0);
+      let organization;
+      if (ctx.organization) {
+        organization = await ctx.management().organizations.get(ctx.organization).then((o) => ({ name: o.name, role: o.role, slug: o.slug })).catch((e) => {
+          if (isMynaApiError(e)) return void 0;
+          throw e;
+        });
+      }
+      emit({ apiUrl: ctx.apiUrl, authenticated: true, account: account ?? null, organization: organization ?? null }, () => {
+        const pairs = [["API", ctx.apiUrl], ["Authenticated", "yes"]];
+        if (account && typeof account === "object" && "username" in account) {
+          pairs.push(["User", String(account.username)]);
+        } else {
+          pairs.push(["Credential", "API token"]);
+        }
+        if (organization) pairs.push(["Organization", `${organization.name} (${organization.role})`]);
+        keyValues(pairs);
+      });
+    })
+  );
+}
+
+// src/commands/workspace.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+var EXAMPLE_SCHEMA = `import { collection, field } from "@myna-sh/schema";
+
+/**
+ * Example collection. Edit freely, then run:
+ *   myna schema diff
+ *   myna schema push
+ */
+export const posts = collection({
+  name: "posts",
+  label: "Blog posts",
+  visibility: "public",
+  titleField: "title",
+  path: "/blog/{slug}",
+  fields: {
+    title: field.text({ required: true, maxLength: 120 }),
+    slug: field.slug({ from: "title", required: true }),
+    description: field.text({ multiline: true }),
+    body: field.markdown({ required: true }),
+    cover: field.asset({ allowed: ["image/*"] }),
+    publishedAt: field.datetime(),
+  },
+});
+`;
+function appUrlFor(apiUrl) {
+  try {
+    const url = new URL(apiUrl);
+    if (url.hostname.startsWith("api.")) {
+      url.hostname = "app." + url.hostname.slice(4);
+      return url.origin;
+    }
+    return apiUrl;
+  } catch {
+    return apiUrl;
+  }
+}
+function registerWorkspace(program) {
+  program.command("init").description("Scaffold a local `myna/` schema directory (and link if a project is set)").option("--schema-dir <dir>", "schema directory", "myna").action(
+    handle(async (ctx, _args, opts) => {
+      const dir = opts.schemaDir ?? "myna";
+      mkdirSync2(dir, { recursive: true });
+      const file = join2(dir, "posts.ts");
+      const created = [];
+      if (!existsSync2(file)) {
+        writeFileSync2(file, EXAMPLE_SCHEMA);
+        created.push(file);
+      }
+      let linked = false;
+      if (ctx.project) {
+        writeLinkedProject(process.cwd(), {
+          project: ctx.project,
+          organization: ctx.organization,
+          ...ctx.apiUrl !== DEFAULT_API_URL2 ? { apiUrl: ctx.apiUrl } : {}
+        });
+        created.push(".myna/project.json");
+        linked = true;
+      }
+      emit({ schemaDir: dir, created, linked }, () => {
+        diag(`Initialized ${dir}/`);
+        for (const c of created) process.stdout.write(`  created ${c}
+`);
+        if (!linked) process.stdout.write(`  run \`myna link --project <ref>\` to link a project
+`);
+      });
+    })
+  );
+  program.command("link").description("Link the current directory to a project (writes .myna/project.json, no secrets)").argument("[project]", "project id or slug").action(
+    handle(async (ctx, args) => {
+      const project = args[0] ?? ctx.project;
+      if (!project) throw new UsageError("Provide a project: `myna link <project>` or --project.");
+      const resolved = await ctx.management().projects.get(project);
+      writeLinkedProject(process.cwd(), {
+        project,
+        organization: ctx.organization ?? resolved.organizationId,
+        ...ctx.apiUrl !== DEFAULT_API_URL2 ? { apiUrl: ctx.apiUrl } : {}
+      });
+      emit(
+        { linked: true, project: resolved.slug, organizationId: resolved.organizationId },
+        () => process.stdout.write(`Linked to ${resolved.name} (${resolved.slug})
+`)
+      );
+    })
+  );
+  program.command("unlink").description("Remove the project link from the current directory tree").action(
+    handle(async () => {
+      const found = findLinkedProject();
+      if (!found) throw new CliError("No linked project found.");
+      removeLinkedProject(found.root);
+      emit({ unlinked: true }, () => process.stdout.write(`Unlinked ${found.linked.project}
+`));
+    })
+  );
+  program.command("status").description("Show the resolved configuration and project link").action(
+    handle(async (ctx) => {
+      const hasToken = Boolean(ctx.token ?? loadToken(ctx.apiUrl));
+      emit(
+        {
+          apiUrl: ctx.apiUrl,
+          authenticated: hasToken,
+          project: ctx.project ?? null,
+          organization: ctx.organization ?? null,
+          linkedRoot: ctx.linkedRoot ?? null
+        },
+        () => keyValues([
+          ["API URL", ctx.apiUrl],
+          ["Authenticated", hasToken ? "yes" : "no"],
+          ["Project", ctx.project ?? "(none)"],
+          ["Organization", ctx.organization ?? "(none)"],
+          ["Linked at", ctx.linkedRoot ?? "(none)"]
+        ])
+      );
+    })
+  );
+  program.command("open").description("Open the current project in the dashboard").action(
+    handle(async (ctx) => {
+      const app = appUrlFor(ctx.apiUrl);
+      const path = ctx.organization && ctx.project ? `/${ctx.organization}/${ctx.project}` : "";
+      const url = `${app}${path}`;
+      if (ctx.interactive) openBrowser(url);
+      emit({ url }, () => process.stdout.write(`${url}
+`));
+    })
+  );
+}
+
+// src/commands/schema.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+
+// src/schema-loader.ts
+import { existsSync as existsSync3, readdirSync, statSync } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
+import { build } from "esbuild";
+
+// ../schema/dist/canonical.js
+function canonicalStringify(value) {
+  return JSON.stringify(sortValue(value));
+}
+function sortValue(value) {
+  if (Array.isArray(value))
+    return value.map(sortValue);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      const v = value[key];
+      if (v === void 0)
+        continue;
+      out[key] = sortValue(v);
+    }
+    return out;
+  }
+  return value;
+}
+function toCanonical(schema) {
+  return JSON.parse(canonicalStringify(schema));
+}
+
+// src/schema-loader.ts
+var DEFAULT_SCHEMA_DIR = "myna";
+function looksLikeCollection(value) {
+  return typeof value === "object" && value !== null && typeof value.name === "string" && Array.isArray(value.fields);
+}
+function collectFromModule(mod, out) {
+  const consider = (value) => {
+    if (Array.isArray(value)) {
+      for (const v of value) consider(v);
+      return;
+    }
+    if (looksLikeCollection(value)) out.set(value.name, value);
+  };
+  for (const value of Object.values(mod)) consider(value);
+}
+function listSchemaFiles(dir) {
+  const files = [];
+  for (const entry of readdirSync(dir)) {
+    if (entry.startsWith(".") || entry === "node_modules" || entry === "dist") continue;
+    const full = join3(dir, entry);
+    const st = statSync(full);
+    if (st.isDirectory()) {
+      files.push(...listSchemaFiles(full));
+    } else if (/\.(ts|mts|js|mjs)$/.test(entry) && !/\.d\.ts$/.test(entry)) {
+      files.push(full);
+    }
+  }
+  return files.sort();
+}
+async function loadLocalSchemas(schemaDir = DEFAULT_SCHEMA_DIR) {
+  const dir = resolve2(schemaDir);
+  if (!existsSync3(dir)) {
+    throw new CliError(`Schema directory not found: ${schemaDir}. Run \`myna init\` to scaffold it.`);
+  }
+  const files = listSchemaFiles(dir);
+  if (files.length === 0) {
+    throw new CliError(`No schema files found in ${schemaDir}.`);
+  }
+  const collections = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const result = await build({
+      entryPoints: [file],
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "node",
+      target: "node20",
+      logLevel: "silent",
+      absWorkingDir: process.cwd()
+    }).catch((error) => {
+      throw new CliError(`Failed to compile ${file}: ${error instanceof Error ? error.message : String(error)}`);
+    });
+    const code = result.outputFiles[0]?.text ?? "";
+    const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
+    const mod = await import(dataUrl);
+    collectFromModule(mod, collections);
+  }
+  if (collections.size === 0) {
+    throw new CliError("No collections were exported from the schema directory.");
+  }
+  return [...collections.values()].map((c) => toCanonical(c)).sort((a, b) => a.name.localeCompare(b.name));
+}
+function canonicalJson(schemas) {
+  return schemas.map((s) => s);
+}
+function schemaDirFor(root, override) {
+  if (override) return override;
+  if (root) {
+    const candidate = join3(root, DEFAULT_SCHEMA_DIR);
+    if (existsSync3(candidate)) return candidate;
+  }
+  return DEFAULT_SCHEMA_DIR;
+}
+
+// src/dsl-emit.ts
+function schemaToDsl(schema) {
+  const opts = [
+    `name: ${str(schema.name)}`,
+    `label: ${str(schema.label)}`
+  ];
+  if (schema.kind !== "collection") opts.push(`kind: ${str(schema.kind)}`);
+  opts.push(`visibility: ${str(schema.visibility)}`);
+  if (schema.titleField) opts.push(`titleField: ${str(schema.titleField)}`);
+  if (schema.path) opts.push(`path: ${str(schema.path)}`);
+  const fieldLines = schema.fields.map((f) => `    ${ident(f.key)}: ${emitField(f)},`).join("\n");
+  return [
+    `import { collection, field, item } from "@myna-sh/schema";`,
+    ``,
+    `export const ${varName(schema.name)} = collection({`,
+    `  ${opts.join(",\n  ")},`,
+    `  fields: {`,
+    fieldLines,
+    `  },`,
+    `});`,
+    ``
+  ].join("\n");
+}
+function emitField(field) {
+  const o = {};
+  if (field.label && field.label !== field.key) o.label = field.label;
+  if (field.description) o.description = field.description;
+  if (field.required) o.required = true;
+  switch (field.type) {
+    case "text":
+      assign(o, { multiline: field.multiline || void 0, minLength: field.minLength, maxLength: field.maxLength, pattern: field.pattern, enum: field.enum, default: field.default });
+      return call("text", o);
+    case "slug":
+      assign(o, { from: field.from });
+      return call("slug", o);
+    case "markdown":
+      assign(o, { minLength: field.minLength, maxLength: field.maxLength, default: field.default });
+      return call("markdown", o);
+    case "number":
+      assign(o, { integer: field.integer || void 0, min: field.min, max: field.max, default: field.default });
+      return call("number", o);
+    case "boolean":
+      assign(o, { default: field.default });
+      return call("boolean", o);
+    case "date":
+    case "datetime":
+      assign(o, { min: field.min, max: field.max, default: field.default });
+      return call(field.type, o);
+    case "json":
+      assign(o, { default: field.default });
+      return call("json", o);
+    case "asset":
+      assign(o, { allowed: field.allowed, multiple: field.multiple || void 0 });
+      return call("asset", o);
+    case "reference":
+      assign(o, { to: field.target, multiple: field.multiple || void 0 });
+      return call("reference", o);
+    case "object": {
+      const inner = field.fields.map((f) => `      ${ident(f.key)}: ${emitField(f)}`).join(",\n");
+      o.fields = `__RAW__{
+${inner},
+    }`;
+      return call("object", o);
+    }
+    case "list":
+      o.of = `__RAW__${emitItem(field.item)}`;
+      assign(o, { minItems: field.minItems, maxItems: field.maxItems });
+      return call("list", o);
+    default:
+      return `field.json({})`;
+  }
+}
+function emitItem(item) {
+  switch (item.kind) {
+    case "reference":
+      return `item.reference({ to: ${str(item.target)} })`;
+    case "asset":
+      return `item.asset({ allowed: ${JSON.stringify(item.allowed)} })`;
+    case "object": {
+      const inner = item.fields.map((f) => `        ${ident(f.key)}: ${emitField(f)}`).join(",\n");
+      return `item.object({ fields: {
+${inner},
+      } })`;
+    }
+    default:
+      return `item.${item.kind}()`;
+  }
+}
+function call(name, opts) {
+  const entries = Object.entries(opts);
+  if (entries.length === 0) return `field.${name}()`;
+  const body = entries.map(([k, v]) => `${ident(k)}: ${literal(v)}`).join(", ");
+  return `field.${name}({ ${body} })`;
+}
+function assign(target, values) {
+  for (const [k, v] of Object.entries(values)) {
+    if (v !== void 0) target[k] = v;
+  }
+}
+function literal(value) {
+  if (typeof value === "string" && value.startsWith("__RAW__")) return value.slice("__RAW__".length);
+  return JSON.stringify(value);
+}
+function str(value) {
+  return JSON.stringify(value);
+}
+function ident(key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+function varName(name) {
+  const camel = name.replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase());
+  return /^[A-Za-z_$]/.test(camel) ? camel : `_${camel}`;
+}
+
+// src/commands/schema.ts
+async function deployedSchemas(ctx, project) {
+  const mgmt = ctx.management();
+  const collections = await mgmt.schema.collections(project);
+  const out = [];
+  for (const c of collections) {
+    const versions = await mgmt.schema.versions(project, c.key);
+    const latest = versions[0];
+    if (latest) out.push(latest.schemaJson);
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+function registerSchema(program) {
+  const schema = program.command("schema").description("Inspect and deploy code-owned schemas");
+  schema.command("inspect").description("Show deployed collections, or one collection's fields").argument("[collection]", "collection key").action(
+    handle(async (ctx, args) => {
+      const project = ctx.requireProject();
+      const key = args[0];
+      if (!key) {
+        const collections = await ctx.management().schema.collections(project);
+        emit(
+          collections,
+          () => table(collections, [
+            { header: "KEY", value: (c) => c.key },
+            { header: "NAME", value: (c) => c.displayName },
+            { header: "KIND", value: (c) => c.kind },
+            { header: "VISIBILITY", value: (c) => c.visibility }
+          ])
+        );
+        return;
+      }
+      const versions = await ctx.management().schema.versions(project, key);
+      const latest = versions[0];
+      if (!latest) throw new CliError(`Collection ${key} has no versions.`);
+      const s = latest.schemaJson;
+      emit({ collection: key, version: latest.version, schema: s }, () => {
+        diag(`${key} \u2014 v${latest.version} (${s.kind}, ${s.visibility})`);
+        table(s.fields, [
+          { header: "FIELD", value: (f) => f.key },
+          { header: "TYPE", value: (f) => f.type },
+          { header: "REQUIRED", value: (f) => f.required ? "yes" : "" }
+        ]);
+      });
+    })
+  );
+  schema.command("pull").description("Write deployed schemas to local DSL files").option("--schema-dir <dir>", "target schema directory").action(
+    handle(async (ctx, _args, opts) => {
+      const project = ctx.requireProject();
+      const dir = schemaDirFor(ctx.linkedRoot, opts.schemaDir);
+      const schemas = await deployedSchemas(ctx, project);
+      mkdirSync3(dir, { recursive: true });
+      const written = [];
+      for (const s of schemas) {
+        const file = join4(dir, `${s.name}.ts`);
+        writeFileSync3(file, schemaToDsl(s));
+        written.push(file);
+      }
+      emit({ pulled: schemas.length, files: written }, () => {
+        for (const f of written) process.stdout.write(`  wrote ${f}
+`);
+      });
+    })
+  );
+  schema.command("diff").description("Diff local schemas against the deployed schemas").option("--schema-dir <dir>", "schema directory").action(
+    handle(async (ctx, _args, opts) => {
+      const project = ctx.requireProject();
+      const dir = schemaDirFor(ctx.linkedRoot, opts.schemaDir);
+      const local = await loadLocalSchemas(dir);
+      const result = await ctx.management().schema.diff(project, canonicalJson(local));
+      emit(result, () => renderDiff(result));
+    })
+  );
+  schema.command("push").description("Apply local schemas, creating immutable versions").option("--schema-dir <dir>", "schema directory").option("--allow-destructive", "permit destructive schema changes", false).option("--summary <text>", "change summary").action(
+    handle(async (ctx, _args, opts) => {
+      const project = ctx.requireProject();
+      const dir = schemaDirFor(ctx.linkedRoot, opts.schemaDir);
+      const local = await loadLocalSchemas(dir);
+      const collections = canonicalJson(local);
+      const allowDestructive = Boolean(opts.allowDestructive);
+      const plan = await ctx.management().schema.diff(project, collections);
+      if (!ctx.json) renderDiff(plan);
+      if (plan.hasDestructive && !allowDestructive) {
+        throw new UsageError(
+          "This change is destructive. Re-run with --allow-destructive to proceed."
+        );
+      }
+      if (plan.ops.length === 0) {
+        emit({ applied: false, reason: "no-changes", diff: plan }, () => diag("No schema changes to apply."));
+        return;
+      }
+      const pushed = await ctx.management().schema.push(project, collections, { allowDestructive, changeSummary: opts.summary }).catch((error) => {
+        if (isMynaApiError(error) && error.code === "SCHEMA_CHANGE_DESTRUCTIVE") {
+          throw new UsageError("Destructive schema change rejected. Pass --allow-destructive.");
+        }
+        throw error;
+      });
+      emit(
+        pushed,
+        () => diag(`Applied ${pushed.versions.length} schema version(s) (${pushed.diff.classification}).`)
+      );
+    })
+  );
+  const types = program.command("types").description("Generate content types");
+  types.command("generate").description("Generate deterministic TypeScript types from schemas").option("--schema-dir <dir>", "schema directory").option("--deployed", "use deployed schemas instead of local files", false).option("--out <file>", "write to a file instead of stdout").action(
+    handle(async (ctx, _args, opts) => {
+      let schemas;
+      if (opts.deployed) {
+        schemas = await deployedSchemas(ctx, ctx.requireProject());
+      } else {
+        const dir = schemaDirFor(ctx.linkedRoot, opts.schemaDir);
+        schemas = await loadLocalSchemas(dir);
+      }
+      const code = generateTypesModule(schemas);
+      const out = opts.out;
+      if (out) {
+        writeFileSync3(out, code);
+        emit({ written: out, collections: schemas.length }, () => diag(`Wrote ${out}`));
+      } else if (ctx.json) {
+        emit({ code, collections: schemas.length });
+      } else {
+        process.stdout.write(code);
+      }
+    })
+  );
+}
+function renderDiff(diff) {
+  if (diff.ops.length === 0) {
+    diag("No changes.");
+    return;
+  }
+  for (const op of diff.ops) {
+    const marker = op.classification === "destructive" ? "!" : op.classification === "conditionally_destructive" ? "~" : "+";
+    const target = op.field ? `${op.collection}.${op.field}` : op.collection;
+    process.stdout.write(`  ${marker} ${op.kind} ${target} \u2014 ${op.detail}
+`);
+  }
+  process.stdout.write(`  classification: ${diff.classification}
+`);
+  for (const err of diff.contentValidationErrors) {
+    process.stderr.write(`  content error: ${err.collection} ${err.path} \u2014 ${err.message}
+`);
+  }
+}
+
+// src/commands/entries.ts
+function registerEntries(program) {
+  const entries = program.command("entries").description("Create, read, update, and manage entries");
+  entries.command("list").description("List entries in a collection").argument("<collection>", "collection key").option("--status <status>", "filter by status").option("--limit <n>", "page size", "25").option("--cursor <cursor>", "pagination cursor").action(
+    handle(async (ctx, args, opts) => {
+      const project = ctx.requireProject();
+      const page = await ctx.management().entries.list(project, {
+        collection: args[0],
+        status: opts.status,
+        limit: Number(opts.limit),
+        cursor: opts.cursor
+      });
+      emit(
+        { data: page.data, nextCursor: page.nextCursor },
+        () => table(page.data, [
+          { header: "ID", value: (e) => e.id },
+          { header: "SLUG", value: (e) => e.slug ?? "" },
+          { header: "STATUS", value: (e) => e.status },
+          { header: "UPDATED", value: (e) => e.updatedAt }
+        ])
+      );
+    })
+  );
+  entries.command("get").description("Get one entry by <collection>/<slug-or-id>").argument("<ref>", "collection/slug or entry id").action(
+    handle(async (ctx, args) => {
+      const project = ctx.requireProject();
+      const id = await resolveEntryId(ctx.management(), project, args[0]);
+      const entry = await ctx.management().entries.get(project, id);
+      emit(entry);
+    })
+  );
+  entries.command("create").description("Create an entry").argument("<collection>", "collection key").option("--data <json-or-@file>", "entry data as JSON or @file").option("--set <path=value...>", "set individual fields", collect, []).option("--slug <slug>", "explicit slug").option("--change-set <id>", "attach to a change set").option("--summary <text>", "change summary").action(
+    handle(async (ctx, args, opts) => {
+      const project = ctx.requireProject();
+      const data = applySets(parseData(opts.data), opts.set);
+      const entry = await ctx.management().entries.create(project, {
+        collection: args[0],
+        data,
+        slug: opts.slug,
+        changeSetId: opts.changeSet,
+        changeSummary: opts.summary
+      });
+      emit(entry, () => diag(`Created ${entry.id} (${entry.status}).`));
+    })
+  );
+  entries.command("update").description("Update an entry").argument("<ref>", "collection/slug or entry id").option("--data <json-or-@file>", "replacement data as JSON or @file").option("--set <path=value...>", "set individual fields", collect, []).option("--slug <slug>", "new slug").option("--expected-revision <id>", "optimistic concurrency guard").option("--change-set <id>", "attach to a change set").option("--summary <text>", "change summary").action(
+    handle(async (ctx, args, opts) => {
+      const project = ctx.requireProject();
+      const id = await resolveEntryId(ctx.management(), project, args[0]);
+      const sets = opts.set;
+      let data;
+      if (opts.data !== void 0 || sets.length > 0) {
+        const base = opts.data !== void 0 ? parseData(opts.data) : (await ctx.management().entries.get(project, id)).data;
+        data = applySets(base, sets);
+      }
+      if (!data && !opts.slug) throw new UsageError("Nothing to update. Pass --data, --set, or --slug.");
+      const entry = await ctx.management().entries.update(project, id, {
+        data,
+        slug: opts.slug,
+        expectedRevisionId: opts.expectedRevision,
+        changeSetId: opts.changeSet,
+        changeSummary: opts.summary
+      });
+      emit(entry, () => diag(`Updated ${entry.id} (${entry.status}).`));
+    })
+  );
+  entries.command("delete").description("Stage an entry deletion on a change set").argument("<ref>", "collection/slug or entry id").option("--confirm-delete", "required consequence flag", false).option("--change-set <id>", "attach to a change set").action(
+    handle(async (ctx, args, opts) => {
+      if (!opts.confirmDelete) throw new UsageError("Deletion requires --confirm-delete.");
+      const project = ctx.requireProject();
+      const id = await resolveEntryId(ctx.management(), project, args[0]);
+      const result = await ctx.management().entries.delete(project, id, opts.changeSet);
+      emit(result, () => diag(`Staged delete of ${id} on change set ${result.changeSetId}.`));
+    })
+  );
+  entries.command("unpublish").description("Stage an entry unpublish on a change set").argument("<ref>", "collection/slug or entry id").option("--change-set <id>", "attach to a change set").action(
+    handle(async (ctx, args, opts) => {
+      const project = ctx.requireProject();
+      const id = await resolveEntryId(ctx.management(), project, args[0]);
+      const result = await ctx.management().entries.unpublish(project, id, opts.changeSet);
+      emit(result, () => diag(`Staged unpublish of ${id} on change set ${result.changeSetId}.`));
+    })
+  );
+  entries.command("revisions").description("List an entry's revisions").argument("<ref>", "collection/slug or entry id").action(
+    handle(async (ctx, args) => {
+      const project = ctx.requireProject();
+      const id = await resolveEntryId(ctx.management(), project, args[0]);
+      const revisions = await ctx.management().entries.revisions(project, id);
+      emit(
+        revisions,
+        () => table(revisions, [
+          { header: "ID", value: (r) => r.id },
+          { header: "#", value: (r) => String(r.revisionNumber) },
+          { header: "BY", value: (r) => r.createdByType },
+          { header: "CREATED", value: (r) => r.createdAt }
+        ])
+      );
+    })
+  );
+  entries.command("restore").description("Restore a historical revision into a new draft").argument("<ref>", "collection/slug or entry id").requiredOption("--revision <id>", "revision id to restore").action(
+    handle(async (ctx, args, opts) => {
+      const project = ctx.requireProject();
+      const id = await resolveEntryId(ctx.management(), project, args[0]);
+      const result = await ctx.management().entries.restoreRevision(project, id, opts.revision);
+      emit(result, () => diag(`Restored revision ${opts.revision} into ${result.revision.id}.`));
+    })
+  );
+}
+function collect(value, previous) {
+  return [...previous, value];
+}
+
+// src/commands/changes.ts
+function registerChanges(program) {
+  const changes = program.command("changes").description("Manage change sets: validate, preview, publish");
+  changes.command("list").description("List change sets").option("--status <status>", "filter by status").option("--limit <n>", "page size", "25").action(
+    handle(async (ctx, _args, opts) => {
+      const project = ctx.requireProject();
+      const page = await ctx.management().changeSets.list(project, {
+        status: opts.status,
+        limit: Number(opts.limit)
+      });
+      emit(
+        { data: page.data, nextCursor: page.nextCursor },
+        () => table(page.data, [
+          { header: "ID", value: (c) => c.id },
+          { header: "TITLE", value: (c) => c.title },
+          { header: "STATUS", value: (c) => c.status },
+          { header: "ITEMS", value: (c) => String(c.items.length) }
+        ])
+      );
+    })
+  );
+  changes.command("create").description("Create a change set").requiredOption("--title <title>", "change set title").option("--description <text>", "change set description").action(
+    handle(async (ctx, _args, opts) => {
+      const project = ctx.requireProject();
+      const cs = await ctx.management().changeSets.create(project, {
+        title: opts.title,
+        description: opts.description
+      });
+      emit(cs, () => diag(`Created change set ${cs.id}.`));
+    })
+  );
+  changes.command("inspect").description("Show a change set and its items").argument("<id>", "change set id").action(
+    handle(async (ctx, args) => {
+      const project = ctx.requireProject();
+      const cs = await ctx.management().changeSets.get(project, args[0]);
+      emit(cs, () => {
+        diag(`${cs.title} \u2014 ${cs.status}`);
+        table(cs.items, [
+          { header: "TYPE", value: (i) => i.resourceType },
+          { header: "RESOURCE", value: (i) => i.resourceId },
+          { header: "OP", value: (i) => i.operation }
+        ]);
+      });
+    })
+  );
+  changes.command("validate").description("Validate a change set against deployed schemas").argument("<id>", "change set id").action(
+    handle(async (ctx, args) => {
+      const project = ctx.requireProject();
+      const result = await ctx.management().changeSets.validate(project, args[0]);
+      emit(result, () => {
+        if (result.valid) {
+          diag("valid");
+        } else {
+          for (const e of result.errors) {
+            process.stderr.write(`  ${e.resourceId} ${e.path} \u2014 ${e.message}
+`);
+          }
+        }
+      });
+      if (!result.valid) process.exitCode = 1;
+    })
+  );
+  changes.command("preview").description("Create a preview for a change set").argument("<id>", "change set id").action(
+    handle(async (ctx, args) => {
+      const project = ctx.requireProject();
+      const preview = await ctx.management().previews.create(project, { changeSetId: args[0] });
+      emit(preview, () => {
+        process.stdout.write(`${preview.url}
+`);
+        diag(`fallback: ${preview.fallbackUrl}`);
+      });
+    })
+  );
+  changes.command("publish").description("Atomically publish a change set").argument("<id>", "change set id").option("--confirm-publish", "required consequence flag", false).action(
+    handle(async (ctx, args, opts) => {
+      if (!opts.confirmPublish) throw new UsageError("Publishing requires --confirm-publish.");
+      const project = ctx.requireProject();
+      const result = await ctx.management().changeSets.publish(project, args[0]);
+      emit(
+        result,
+        () => diag(`Published ${result.publishedEntryIds.length} entr(y/ies): ${result.publishedEntryIds.join(", ")}`)
+      );
+    })
+  );
+  changes.command("close").description("Close a change set without publishing").argument("<id>", "change set id").action(
+    handle(async (ctx, args) => {
+      const project = ctx.requireProject();
+      const cs = await ctx.management().changeSets.close(project, args[0]);
+      emit(cs, () => diag(`Closed ${cs.id}.`));
+    })
+  );
+}
+
+// src/commands/previews.ts
+function previewTarget(ref) {
+  if (ref.startsWith("chs_")) return { changeSetId: ref };
+  if (ref.startsWith("ent_")) return { entryId: ref };
+  throw new UsageError(`Preview target must be a change-set (chs_) or entry (ent_) id: ${ref}`);
+}
+async function create(ctx, ref) {
+  return ctx.management().previews.create(ctx.requireProject(), previewTarget(ref));
+}
+function registerPreviews(program) {
+  const preview = program.command("preview").description("Create and manage preview links");
+  preview.command("create").description("Create a preview for a change set or entry").argument("<change-set-or-entry>", "chs_ or ent_ id").action(
+    handle(async (ctx, args) => {
+      const p = await create(ctx, args[0]);
+      emit(p, () => {
+        process.stdout.write(`${p.url}
+`);
+        diag(`fallback: ${p.fallbackUrl}`);
+      });
+    })
+  );
+  preview.command("open").description("Create a preview and open it in the browser").argument("<change-set-or-entry>", "chs_ or ent_ id").action(
+    handle(async (ctx, args) => {
+      const p = await create(ctx, args[0]);
+      if (ctx.interactive) openBrowser(p.url);
+      emit(p, () => process.stdout.write(`${p.url}
+`));
+    })
+  );
+  preview.command("list").description("List preview tokens for the project").action(
+    handle(async (ctx) => {
+      const previews = await ctx.management().previews.list(ctx.requireProject());
+      emit(
+        previews,
+        () => table(previews, [
+          { header: "ID", value: (p) => p.id },
+          { header: "SCOPE", value: (p) => p.changeSetId ?? p.entryId ?? "" },
+          { header: "EXPIRES", value: (p) => p.expiresAt },
+          { header: "REVOKED", value: (p) => p.revokedAt ? "yes" : "" }
+        ])
+      );
+    })
+  );
+  preview.command("revoke").description("Revoke a preview token").argument("<id>", "preview id (prv_)").action(
+    handle(async (ctx, args) => {
+      await ctx.management().previews.revoke(ctx.requireProject(), args[0]);
+      emit({ ok: true }, () => diag(`Revoked ${args[0]}.`));
+    })
+  );
+}
+
+// src/commands/assets.ts
+function registerAssets(program) {
+  const assets = program.command("assets").description("Upload and manage assets");
+  assets.command("upload").description("Upload one or more files via the presigned flow").argument("<path...>", "file path(s)").option("--alt <text>", "default alt text applied to each asset").action(
+    handle(async (ctx, args, opts) => {
+      const project = ctx.requireProject();
+      const paths = args[0];
+      const uploaded = [];
+      for (const path of paths) {
+        diag(`uploading ${path} \u2026`);
+        let asset = await ctx.management().assets.upload(project, path);
+        if (opts.alt) asset = await ctx.management().assets.update(project, asset.id, { defaultAlt: opts.alt });
+        uploaded.push(asset);
+      }
+      emit(
+        uploaded.length === 1 ? uploaded[0] : uploaded,
+        () => table(uploaded, [
+          { header: "ID", value: (a) => a.id },
+          { header: "FILENAME", value: (a) => a.displayFilename },
+          { header: "TYPE", value: (a) => a.contentType },
+          { header: "SIZE", value: (a) => String(a.byteSize) },
+          { header: "STATE", value: (a) => a.state }
+        ])
+      );
+    })
+  );
+  assets.command("list").description("List assets").option("--limit <n>", "page size", "25").option("--cursor <cursor>", "pagination cursor").action(
+    handle(async (ctx, _args, opts) => {
+      const project = ctx.requireProject();
+      const page = await ctx.management().assets.list(project, {
+        limit: Number(opts.limit),
+        cursor: opts.cursor
+      });
+      emit(
+        { data: page.data, nextCursor: page.nextCursor },
+        () => table(page.data, [
+          { header: "ID", value: (a) => a.id },
+          { header: "FILENAME", value: (a) => a.displayFilename },
+          { header: "TYPE", value: (a) => a.contentType },
+          { header: "STATE", value: (a) => a.state }
+        ])
+      );
+    })
+  );
+  assets.command("inspect").description("Show an asset and its usage").argument("<id>", "asset id (ast_)").action(
+    handle(async (ctx, args) => {
+      const project = ctx.requireProject();
+      const result = await ctx.management().assets.usage(project, args[0]);
+      emit(result, () => {
+        keyValues([
+          ["ID", result.asset.id],
+          ["Filename", result.asset.displayFilename],
+          ["Type", result.asset.contentType],
+          ["Size", String(result.asset.byteSize)],
+          ["State", result.asset.state],
+          ["URL", result.asset.url],
+          ["Referenced by", result.usage.entryIds.join(", ") || "(none)"]
+        ]);
+      });
+    })
+  );
+  assets.command("delete").description("Soft-delete an asset").argument("<id>", "asset id (ast_)").option("--confirm-delete", "required consequence flag", false).action(
+    handle(async (ctx, args, opts) => {
+      if (!opts.confirmDelete) throw new UsageError("Deletion requires --confirm-delete.");
+      await ctx.management().assets.delete(ctx.requireProject(), args[0]);
+      emit({ ok: true }, () => diag(`Deleted ${args[0]}.`));
+    })
+  );
+}
+
+// src/commands/admin.ts
+function csv(value) {
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function registerAdmin(program) {
+  registerOrganizations(program);
+  registerProjects(program);
+  registerKeys(program);
+  registerMembers(program);
+  registerWebhooks(program);
+  registerActivity(program);
+  registerBilling(program);
+}
+function registerOrganizations(program) {
+  const orgs = program.command("organizations").alias("orgs").description("Manage organizations");
+  orgs.command("list").description("List organizations you belong to").action(
+    handle(async (ctx) => {
+      const list = await ctx.management().organizations.list();
+      emit(
+        list,
+        () => table(list, [
+          { header: "SLUG", value: (o) => o.slug },
+          { header: "NAME", value: (o) => o.name },
+          { header: "ROLE", value: (o) => o.role },
+          { header: "PLAN", value: (o) => o.planKey }
+        ])
+      );
+    })
+  );
+  orgs.command("create").description("Create an organization").requiredOption("--name <name>", "organization name").option("--slug <slug>", "organization slug").action(
+    handle(async (ctx, _args, opts) => {
+      const org = await ctx.management().organizations.create({
+        name: opts.name,
+        slug: opts.slug
+      });
+      emit(org, () => diag(`Created ${org.slug} (${org.id}).`));
+    })
+  );
+  orgs.command("use").description("Set the default organization").argument("<slug>", "organization slug or id").action(
+    handle(async (_ctx, args) => {
+      writeUserConfig({ defaultOrganization: args[0] });
+      emit({ defaultOrganization: args[0] }, () => diag(`Default organization set to ${args[0]}.`));
+    })
+  );
+}
+function registerProjects(program) {
+  const projects = program.command("projects").description("Manage projects");
+  projects.command("list").description("List projects in the organization").action(
+    handle(async (ctx) => {
+      const list = await ctx.management().projects.list(ctx.requireOrganization());
+      emit(
+        list,
+        () => table(list, [
+          { header: "SLUG", value: (p) => p.slug },
+          { header: "NAME", value: (p) => p.name },
+          { header: "PUBLIC API", value: (p) => p.publicApiEnabled ? "on" : "off" },
+          { header: "ARCHIVED", value: (p) => p.archivedAt ? "yes" : "" }
+        ])
+      );
+    })
+  );
+  projects.command("create").description("Create a project").requiredOption("--name <name>", "project name").option("--slug <slug>", "project slug").option("--timezone <tz>", "project timezone").action(
+    handle(async (ctx, _args, opts) => {
+      const project = await ctx.management().projects.create(ctx.requireOrganization(), {
+        name: opts.name,
+        slug: opts.slug,
+        timezone: opts.timezone
+      });
+      emit(project, () => diag(`Created ${project.slug} (${project.id}).`));
+    })
+  );
+  projects.command("inspect").description("Show project details").argument("[project]", "project id or slug").action(
+    handle(async (ctx, args) => {
+      const ref = args[0] ?? ctx.requireProject();
+      const project = await ctx.management().projects.get(ref);
+      emit(
+        project,
+        () => keyValues([
+          ["ID", project.id],
+          ["Name", project.name],
+          ["Slug", project.slug],
+          ["Timezone", project.timezone],
+          ["Public API", project.publicApiEnabled ? "on" : "off"],
+          ["Origins", project.origins.join(", ") || "(none)"]
+        ])
+      );
+    })
+  );
+  projects.command("archive").description("Archive a project").argument("[project]", "project id or slug").action(
+    handle(async (ctx, args) => {
+      const ref = args[0] ?? ctx.requireProject();
+      const project = await ctx.management().projects.archive(ref);
+      emit(project, () => diag(`Archived ${project.slug}.`));
+    })
+  );
+}
+function registerKeys(program) {
+  const keys = program.command("keys").description("Manage API keys");
+  keys.command("list").description("List API keys for the project (or organization with --org-scope)").option("--org-scope", "list organization-scoped keys", false).action(
+    handle(async (ctx, _args, opts) => {
+      const list = opts.orgScope ? await ctx.management().apiKeys.listForOrganization(ctx.requireOrganization()) : await ctx.management().apiKeys.listForProject(ctx.requireProject());
+      emit(
+        list,
+        () => table(list, [
+          { header: "ID", value: (k) => k.id },
+          { header: "NAME", value: (k) => k.name },
+          { header: "SCOPES", value: (k) => k.scopes.join(",") },
+          { header: "REVOKED", value: (k) => k.revokedAt ? "yes" : "" }
+        ])
+      );
+    })
+  );
+  keys.command("create").description("Create an API key (project-scoped by default)").requiredOption("--name <name>", "key name").requiredOption("--scopes <scopes>", "comma-separated scopes").option("--label <label>", "agent/integration label").option("--org-scope", "create an organization-scoped key", false).option("--expires-at <iso>", "expiry (ISO 8601)").action(
+    handle(async (ctx, _args, opts) => {
+      const body = {
+        name: opts.name,
+        scopes: csv(opts.scopes),
+        label: opts.label,
+        expiresAt: opts.expiresAt
+      };
+      const result = opts.orgScope ? await ctx.management().apiKeys.createForOrganization(ctx.requireOrganization(), body) : await ctx.management().apiKeys.createForProject(ctx.requireProject(), body);
+      emit(result, () => {
+        diag("Store this secret now \u2014 it will not be shown again.");
+        keyValues([
+          ["ID", result.key.id],
+          ["Name", result.key.name],
+          ["Secret", result.secret]
+        ]);
+      });
+    })
+  );
+  keys.command("revoke").description("Revoke an API key").argument("<id>", "key id (key_)").option("--org-scope", "revoke an organization-scoped key", false).action(
+    handle(async (ctx, args, opts) => {
+      if (opts.orgScope) {
+        await ctx.management().apiKeys.revokeForOrganization(ctx.requireOrganization(), args[0]);
+      } else {
+        await ctx.management().apiKeys.revokeForProject(ctx.requireProject(), args[0]);
+      }
+      emit({ ok: true }, () => diag(`Revoked ${args[0]}.`));
+    })
+  );
+}
+function registerMembers(program) {
+  const members = program.command("members").description("Manage organization members");
+  members.command("list").description("List members and pending invitations").action(
+    handle(async (ctx) => {
+      const org = ctx.requireOrganization();
+      const [list, invites] = await Promise.all([
+        ctx.management().members.list(org),
+        ctx.management().invitations.list(org).catch(() => [])
+      ]);
+      emit({ members: list, invitations: invites }, () => {
+        table(list, [
+          { header: "USER", value: (m) => m.username ?? m.userId },
+          { header: "EMAIL", value: (m) => m.email },
+          { header: "ROLE", value: (m) => m.role }
+        ]);
+        if (invites.length > 0) {
+          diag("\nPending invitations:");
+          table(invites, [
+            { header: "EMAIL", value: (i) => i.email },
+            { header: "ROLE", value: (i) => i.role },
+            { header: "EXPIRES", value: (i) => i.expiresAt }
+          ]);
+        }
+      });
+    })
+  );
+  members.command("invite").description("Invite a member by email").requiredOption("--email <email>", "invitee email").requiredOption("--role <role>", "role (admin|editor|viewer)").action(
+    handle(async (ctx, _args, opts) => {
+      const invite = await ctx.management().invitations.create(ctx.requireOrganization(), {
+        email: opts.email,
+        role: opts.role
+      });
+      emit(invite, () => diag(`Invited ${invite.email} as ${invite.role}.`));
+    })
+  );
+  members.command("update").description("Update a member's role").argument("<user>", "user id").requiredOption("--role <role>", "new role").action(
+    handle(async (ctx, args, opts) => {
+      await ctx.management().members.update(ctx.requireOrganization(), args[0], {
+        role: opts.role
+      });
+      emit({ ok: true }, () => diag(`Updated ${args[0]} to ${opts.role}.`));
+    })
+  );
+  members.command("remove").description("Remove a member").argument("<user>", "user id").action(
+    handle(async (ctx, args) => {
+      await ctx.management().members.remove(ctx.requireOrganization(), args[0]);
+      emit({ ok: true }, () => diag(`Removed ${args[0]}.`));
+    })
+  );
+}
+function registerWebhooks(program) {
+  const webhooks = program.command("webhooks").description("Manage webhook endpoints");
+  webhooks.command("list").description("List webhook endpoints").action(
+    handle(async (ctx) => {
+      const list = await ctx.management().webhooks.list(ctx.requireProject());
+      emit(
+        list,
+        () => table(list, [
+          { header: "ID", value: (w) => w.id },
+          { header: "URL", value: (w) => w.url },
+          { header: "EVENTS", value: (w) => w.events.join(",") },
+          { header: "ENABLED", value: (w) => w.enabled ? "yes" : "no" }
+        ])
+      );
+    })
+  );
+  webhooks.command("create").description("Create a webhook endpoint").requiredOption("--url <url>", "endpoint URL").requiredOption("--events <events>", "comma-separated event types").action(
+    handle(async (ctx, _args, opts) => {
+      const result = await ctx.management().webhooks.create(ctx.requireProject(), {
+        url: opts.url,
+        events: csv(opts.events),
+        enabled: true
+      });
+      emit(result, () => {
+        diag("Store this signing secret now \u2014 it will not be shown again.");
+        keyValues([
+          ["ID", result.endpoint.id],
+          ["URL", result.endpoint.url],
+          ["Signing secret", result.signingSecret]
+        ]);
+      });
+    })
+  );
+  webhooks.command("update").description("Update a webhook endpoint").argument("<id>", "webhook id").option("--url <url>", "new URL").option("--events <events>", "comma-separated event types").option("--enabled <bool>", "enable/disable (true|false)").action(
+    handle(async (ctx, args, opts) => {
+      const patch = {};
+      if (opts.url) patch.url = opts.url;
+      if (opts.events) patch.events = csv(opts.events);
+      if (opts.enabled !== void 0) patch.enabled = opts.enabled === "true";
+      const endpoint = await ctx.management().webhooks.update(ctx.requireProject(), args[0], patch);
+      emit(endpoint, () => diag(`Updated ${endpoint.id}.`));
+    })
+  );
+  webhooks.command("delete").description("Delete a webhook endpoint").argument("<id>", "webhook id").action(
+    handle(async (ctx, args) => {
+      await ctx.management().webhooks.delete(ctx.requireProject(), args[0]);
+      emit({ ok: true }, () => diag(`Deleted ${args[0]}.`));
+    })
+  );
+  webhooks.command("deliveries").description("List recent deliveries for a webhook").argument("<id>", "webhook id").action(
+    handle(async (ctx, args) => {
+      const list = await ctx.management().webhooks.deliveries(ctx.requireProject(), args[0]);
+      emit(
+        list,
+        () => table(list, [
+          { header: "ID", value: (d) => d.id },
+          { header: "EVENT", value: (d) => d.eventType },
+          { header: "ATTEMPT", value: (d) => String(d.attempt) },
+          { header: "STATUS", value: (d) => d.status },
+          { header: "HTTP", value: (d) => d.responseStatus ? String(d.responseStatus) : "" }
+        ])
+      );
+    })
+  );
+  webhooks.command("retry").description("Retry a webhook delivery").argument("<webhook>", "webhook id").argument("<delivery>", "delivery id").action(
+    handle(async (ctx, args) => {
+      await ctx.management().webhooks.retry(ctx.requireProject(), args[0], args[1]);
+      emit({ ok: true }, () => diag(`Retrying delivery ${args[1]}.`));
+    })
+  );
+}
+function registerActivity(program) {
+  program.command("activity").description("Show the project activity feed").option("--actor-type <type>", "filter by actor type").option("--action <action>", "filter by action").option("--limit <n>", "page size", "25").action(
+    handle(async (ctx, _args, opts) => {
+      const page = await ctx.management().activity(ctx.requireProject(), {
+        actorType: opts.actorType,
+        action: opts.action,
+        limit: Number(opts.limit)
+      });
+      emit(
+        { data: page.data, nextCursor: page.nextCursor },
+        () => table(page.data, [
+          { header: "WHEN", value: (a) => a.createdAt },
+          { header: "ACTOR", value: (a) => a.actorType },
+          { header: "ACTION", value: (a) => a.action },
+          { header: "TARGET", value: (a) => `${a.targetType ?? ""} ${a.targetId ?? ""}`.trim() }
+        ])
+      );
+    })
+  );
+}
+function registerBilling(program) {
+  const billing = program.command("billing").description("Billing status and management");
+  billing.command("status").description("Show the organization's plan and usage").action(
+    handle(async (ctx) => {
+      const org = ctx.requireOrganization();
+      const [status, usage] = await Promise.all([
+        ctx.management().billing.status(org),
+        ctx.management().organizations.usage(org).catch(() => void 0)
+      ]);
+      emit({ billing: status, usage }, () => {
+        keyValues([
+          ["Plan", status.subscription.planKey],
+          ["Status", status.subscription.status],
+          ["Provider customer", status.hasProviderCustomer ? "yes" : "no"]
+        ]);
+        if (usage) {
+          diag("\nUsage:");
+          table(usage.metrics, [
+            { header: "METRIC", value: (m) => m.metric },
+            { header: "USED", value: (m) => String(m.quantity) },
+            { header: "LIMIT", value: (m) => m.limit === null ? "\u221E" : String(m.limit) }
+          ]);
+        }
+      });
+    })
+  );
+  billing.command("upgrade").description("Start a Pro checkout").option("--interval <interval>", "month|year", "month").action(
+    handle(async (ctx, _args, opts) => {
+      const result = await ctx.management().billing.checkout(ctx.requireOrganization(), {
+        interval: opts.interval ?? "month"
+      });
+      if (ctx.interactive) openBrowser(result.checkoutUrl);
+      emit(result, () => process.stdout.write(`${result.checkoutUrl}
+`));
+    })
+  );
+  billing.command("portal").description("Open the billing portal").action(
+    handle(async (ctx) => {
+      const result = await ctx.management().billing.portal(ctx.requireOrganization());
+      if (ctx.interactive) openBrowser(result.portalUrl);
+      emit(result, () => process.stdout.write(`${result.portalUrl}
+`));
+    })
+  );
+}
+
+// src/main.ts
+var VERSION = "0.1.0";
+var GLOBAL_VALUE_FLAGS = /* @__PURE__ */ new Set(["--project", "--organization", "--token", "--api-url"]);
+var GLOBAL_BOOL_FLAGS = /* @__PURE__ */ new Set(["--json", "--no-interactive", "--interactive"]);
+function normalizeGlobals(argv) {
+  const [node, script, ...rest] = argv;
+  const globals = [];
+  const remaining = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    const eq = arg.indexOf("=");
+    const name = eq === -1 ? arg : arg.slice(0, eq);
+    if (GLOBAL_BOOL_FLAGS.has(name)) {
+      globals.push(arg);
+    } else if (GLOBAL_VALUE_FLAGS.has(name)) {
+      if (eq === -1) {
+        globals.push(arg);
+        if (i + 1 < rest.length) globals.push(rest[++i]);
+      } else {
+        globals.push(arg);
+      }
+    } else {
+      remaining.push(arg);
+    }
+  }
+  return [node, script, ...globals, ...remaining];
+}
+function buildProgram() {
+  const program = new Command();
+  program.name("myna").description("Myna \u2014 content infrastructure for developers and agents").version(VERSION, "-v, --version").option("--json", "emit a single machine-readable JSON value on stdout").option("--project <ref>", "project id or slug").option("--organization <ref>", "organization id or slug").option("--token <token>", "API token (overrides stored credentials)").option("--api-url <url>", "API base URL").option("--no-interactive", "disable prompts and browser opening").showHelpAfterError();
+  registerAuth(program);
+  registerWorkspace(program);
+  registerSchema(program);
+  registerEntries(program);
+  registerChanges(program);
+  registerPreviews(program);
+  registerAssets(program);
+  registerAdmin(program);
+  return program;
+}
+async function main(argv = process.argv) {
+  const program = buildProgram();
+  program.exitOverride();
+  try {
+    await program.parseAsync(normalizeGlobals(argv));
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      if (error.code === "commander.helpDisplayed" || error.code === "commander.version" || error.code === "commander.help") {
+        process.exitCode = 0;
+        return;
+      }
+      process.exitCode = 2;
+      return;
+    }
+    process.stderr.write(`error: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 1;
+  }
+}
+export {
+  buildProgram,
+  main
+};
+//# sourceMappingURL=main.js.map