@mymehq/sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,184 @@
+import { ConflictSnapshot, ItemState, CreateItemInput, Item, PaginatedResult, ItemWithMetadata, Version, Metadata, SearchResult, Thread, TypeSchema, CreateKeyInput, ApiKey, CreateWebhookInput, Webhook, UpdateWebhookInput, WebhookDelivery } from '@mymehq/shared';
+export { ApiKey, ConflictSnapshot, CreateItemInput, CreateKeyInput, Item, ItemState, Metadata, PaginatedResult, SearchResult, Thread, TypeSchema, Version } from '@mymehq/shared';
+
+/**
+ * Conflict resolution strategy for item updates.
+ *
+ * - `"auto"` (default): Non-conflicting field changes merge automatically.
+ *   Conflicting fields use the server's current value. Retries up to 3 times.
+ * - `"manual"`: Throws a `ConflictError` with both versions and the list of
+ *   conflicting fields. The caller decides how to resolve.
+ * - `"callback"`: Calls a custom `ConflictResolver` function with the conflict
+ *   data. The resolver returns the merged properties to submit.
+ */
+type ConflictStrategy = "auto" | "manual" | "callback";
+interface ConflictData {
+    current: ConflictSnapshot;
+    ancestor: ConflictSnapshot;
+    conflictingFields: string[];
+    clientPatch: Record<string, unknown>;
+}
+type ConflictResolver = (conflict: ConflictData) => Record<string, unknown> | Promise<Record<string, unknown>>;
+
+interface ClientConfig {
+    url: string;
+    apiKey: string;
+    fetch?: typeof globalThis.fetch;
+    /**
+     * Default conflict resolution strategy for all updates.
+     * Can be overridden per-call via `UpdateOptions.conflict`.
+     * Defaults to `"auto"` — non-conflicting fields merge, conflicting fields
+     * use the server's value.
+     */
+    conflictStrategy?: ConflictStrategy;
+    timeoutMs?: number;
+    cdnBaseUrl?: string;
+}
+interface UpdateOptions {
+    version?: number;
+    thread_id?: string | null;
+    /**
+     * Override the client's default conflict strategy for this update.
+     * - `"auto"`: auto-merge non-conflicting fields (default)
+     * - `"manual"`: throw `ConflictError` with both versions
+     * - `"callback"`: call the `resolve` function to handle the conflict
+     */
+    conflict?: ConflictStrategy;
+    /** Custom conflict resolver (required when `conflict` is `"callback"`). */
+    resolve?: ConflictResolver;
+}
+interface ListFilters {
+    type?: string;
+    state?: ItemState;
+    source?: string;
+    parent_id?: string;
+    thread_id?: string;
+    root_only?: boolean;
+    tags?: string[];
+    filter?: string;
+    sort?: "created_at" | "updated_at" | "timestamp";
+    direction?: "asc" | "desc";
+    since?: string;
+    until?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface SearchFilters {
+    type?: string;
+    state?: ItemState;
+    filter?: string;
+    limit?: number;
+}
+interface MetadataInput {
+    tags?: string[];
+    about?: string[];
+}
+declare class MymeClient {
+    private readonly transport;
+    private readonly defaultConflictStrategy;
+    private readonly apiBaseUrl;
+    private readonly cdnBaseUrl?;
+    constructor(config: ClientConfig);
+    readonly items: {
+        create: (input: CreateItemInput) => Promise<Item>;
+        get: (id: string) => Promise<Item>;
+        list: (filters?: ListFilters) => Promise<PaginatedResult<Item>>;
+        listWithMetadata: (filters?: Omit<ListFilters, "include">) => Promise<PaginatedResult<ItemWithMetadata>>;
+        update: (id: string, properties: Record<string, unknown>, options?: UpdateOptions) => Promise<Item>;
+        delete: (id: string) => Promise<void>;
+        restore: (id: string) => Promise<Item>;
+        transition: (id: string, state: string) => Promise<Item>;
+        versions: (id: string) => Promise<Version[]>;
+        stats: () => Promise<Record<string, number>>;
+    };
+    readonly metadata: {
+        get: (itemId: string) => Promise<Metadata>;
+        set: (itemId: string, input: MetadataInput) => Promise<Metadata>;
+        merge: (itemId: string, input: Partial<MetadataInput>) => Promise<Metadata>;
+        addTags: (itemId: string, tags: string[]) => Promise<Metadata>;
+        removeTag: (itemId: string, tag: string) => Promise<void>;
+        getExtensions: (itemId: string, namespace?: string) => Promise<Record<string, Record<string, unknown>>>;
+        setExtension: (itemId: string, namespace: string, data: Record<string, unknown>) => Promise<Record<string, Record<string, unknown>>>;
+        deleteExtension: (itemId: string, namespace: string) => Promise<void>;
+    };
+    search(query: string, filters?: SearchFilters): Promise<SearchResult[]>;
+    readonly threads: {
+        create: () => Promise<Thread>;
+        list: (filters?: {
+            limit?: number;
+            cursor?: string;
+        }) => Promise<PaginatedResult<Thread>>;
+        get: (id: string) => Promise<{
+            thread: Thread;
+            items: Item[];
+        }>;
+        addItem: (threadId: string, itemId: string) => Promise<Item>;
+        removeItem: (threadId: string, itemId: string) => Promise<Item>;
+    };
+    readonly blobs: {
+        upload: (data: Uint8Array | ArrayBuffer, mimeType: string) => Promise<{
+            hash: string;
+        }>;
+        download: (hash: string) => Promise<ArrayBuffer>;
+        /** Check whether a blob exists without downloading it. */
+        exists: (hash: string) => Promise<boolean>;
+        /** Returns a direct CDN URL if configured, otherwise the API proxy URL. */
+        url: (hash: string) => string;
+    };
+    readonly types: {
+        list: () => Promise<TypeSchema[]>;
+        get: (id: string) => Promise<TypeSchema>;
+        register: (schema: TypeSchema) => Promise<TypeSchema>;
+        update: (id: string, schema: Omit<TypeSchema, "id">) => Promise<TypeSchema>;
+        delete: (id: string, options?: {
+            force?: boolean;
+        }) => Promise<void>;
+    };
+    readonly keys: {
+        create: (input: CreateKeyInput) => Promise<{
+            id: string;
+            key: string;
+        }>;
+        list: () => Promise<ApiKey[]>;
+        revoke: (id: string) => Promise<void>;
+    };
+    readonly webhooks: {
+        create: (input: CreateWebhookInput) => Promise<Webhook>;
+        list: () => Promise<Webhook[]>;
+        get: (id: string) => Promise<Webhook>;
+        update: (id: string, input: UpdateWebhookInput) => Promise<Webhook>;
+        delete: (id: string) => Promise<void>;
+        deliveries: (id: string, options?: {
+            limit?: number;
+        }) => Promise<WebhookDelivery[]>;
+    };
+    private throwRawError;
+}
+
+declare class MymeError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly details?: Record<string, unknown>;
+    constructor(code: string, message: string, status: number, details?: Record<string, unknown>);
+}
+declare class NotFoundError extends MymeError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class ValidationError extends MymeError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class UnauthorizedError extends MymeError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class ForbiddenError extends MymeError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class ConflictError extends MymeError {
+    readonly current: ConflictSnapshot;
+    readonly ancestor: ConflictSnapshot;
+    readonly conflictingFields: string[];
+    readonly clientPatch: Record<string, unknown>;
+    constructor(current: ConflictSnapshot, ancestor: ConflictSnapshot, conflictingFields: string[], clientPatch: Record<string, unknown>);
+}
+
+export { type ClientConfig, type ConflictData, ConflictError, type ConflictResolver, type ConflictStrategy, ForbiddenError, type ListFilters, type MetadataInput, MymeClient, MymeError, NotFoundError, type SearchFilters, UnauthorizedError, type UpdateOptions, ValidationError };

package/dist/index.js

@@ -0,0 +1,576 @@
+// src/errors.ts
+var MymeError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(code, message, status, details) {
+    super(message);
+    this.name = "MymeError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+};
+var NotFoundError = class extends MymeError {
+  constructor(message, details) {
+    super("not_found", message, 404, details);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends MymeError {
+  constructor(message, details) {
+    super("validation_error", message, 400, details);
+    this.name = "ValidationError";
+  }
+};
+var UnauthorizedError = class extends MymeError {
+  constructor(message, details) {
+    super("unauthorized", message, 401, details);
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends MymeError {
+  constructor(message, details) {
+    super("forbidden", message, 403, details);
+    this.name = "ForbiddenError";
+  }
+};
+var ConflictError = class extends MymeError {
+  current;
+  ancestor;
+  conflictingFields;
+  clientPatch;
+  constructor(current, ancestor, conflictingFields, clientPatch) {
+    super("version_conflict", "Version conflict", 409);
+    this.name = "ConflictError";
+    this.current = current;
+    this.ancestor = ancestor;
+    this.conflictingFields = conflictingFields;
+    this.clientPatch = clientPatch;
+  }
+};
+
+// src/transport.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var HttpTransport = class {
+  baseUrl;
+  apiKey;
+  fetch;
+  timeoutMs;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+    this.fetch = config.fetch ?? globalThis.fetch.bind(globalThis);
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  async request(method, path, options) {
+    const response = await this.rawRequest(method, path, options);
+    if (response.status === 204) {
+      return void 0;
+    }
+    const body = await response.json();
+    if (!response.ok) {
+      this.throwForError(response.status, body);
+    }
+    return body;
+  }
+  /**
+   * Like request(), but returns the conflict response instead of throwing
+   * when the server responds with 409. Returns either the success body or
+   * the ConflictResponse for the caller to handle.
+   */
+  async requestWithConflict(method, path, options) {
+    const response = await this.rawRequest(method, path, options);
+    const body = await response.json();
+    if (response.status === 409) {
+      return body;
+    }
+    if (!response.ok) {
+      this.throwForError(response.status, body);
+    }
+    return body;
+  }
+  async rawRequest(method, path, options) {
+    const url = this.buildUrl(path, options?.query);
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      ...options?.headers
+    };
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+      controller.abort();
+    }, this.timeoutMs);
+    const init = { method, headers, signal: controller.signal };
+    if (options?.rawBody !== void 0) {
+      init.body = options.rawBody;
+    } else if (options?.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(options.body);
+    }
+    try {
+      return await this.fetch(url, init);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  buildUrl(path, query) {
+    const url = `${this.baseUrl}${path}`;
+    if (!query) return url;
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) {
+        params.set(key, String(value));
+      }
+    }
+    const qs = params.toString();
+    return qs ? `${url}?${qs}` : url;
+  }
+  throwForError(status, body) {
+    const parsed = body;
+    const errObj = parsed?.error;
+    const message = errObj?.message ?? `HTTP ${String(status)}`;
+    const details = errObj?.details;
+    const code = errObj?.code ?? "unknown";
+    switch (status) {
+      case 400:
+        throw new ValidationError(message, details);
+      case 401:
+        throw new UnauthorizedError(message, details);
+      case 403:
+        throw new ForbiddenError(message, details);
+      case 404:
+        throw new NotFoundError(message, details);
+      default:
+        throw new MymeError(code, message, status, details);
+    }
+  }
+};
+
+// src/conflict.ts
+var MAX_RETRIES = 3;
+function isConflictResponse(body) {
+  return typeof body === "object" && body !== null && "error" in body && "current" in body && "conflicting_fields" in body;
+}
+function autoMerge(conflict) {
+  const merged = { ...conflict.current.properties };
+  for (const [key, value] of Object.entries(conflict.clientPatch)) {
+    if (!conflict.conflictingFields.includes(key)) {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function toConflictError(response, clientPatch) {
+  return new ConflictError(
+    response.current,
+    response.ancestor,
+    response.conflicting_fields,
+    clientPatch
+  );
+}
+async function handleConflictUpdate(transport, itemId, clientPatch, version, strategy, resolver, threadId) {
+  let properties = clientPatch;
+  let currentVersion = version;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    const result = await transport.requestWithConflict("PATCH", `/items/${itemId}`, {
+      body: {
+        properties,
+        version: currentVersion,
+        ...threadId !== void 0 && { thread_id: threadId }
+      }
+    });
+    if (!isConflictResponse(result)) {
+      return result.item;
+    }
+    if (strategy === "manual") {
+      throw toConflictError(result, clientPatch);
+    }
+    if (attempt === MAX_RETRIES) {
+      throw toConflictError(result, clientPatch);
+    }
+    const conflict = {
+      current: result.current,
+      ancestor: result.ancestor,
+      conflictingFields: result.conflicting_fields,
+      clientPatch
+    };
+    if (strategy === "auto") {
+      properties = autoMerge(conflict);
+    } else {
+      if (!resolver) {
+        throw toConflictError(result, clientPatch);
+      }
+      properties = await resolver(conflict);
+    }
+    currentVersion = result.current.version;
+  }
+  throw new ConflictError(
+    { version: 0, properties: {} },
+    { version: 0, properties: {} },
+    [],
+    clientPatch
+  );
+}
+
+// src/client.ts
+var MymeClient = class {
+  transport;
+  defaultConflictStrategy;
+  apiBaseUrl;
+  cdnBaseUrl;
+  constructor(config) {
+    this.apiBaseUrl = config.url.replace(/\/+$/, "");
+    this.transport = new HttpTransport({
+      baseUrl: config.url,
+      apiKey: config.apiKey,
+      fetch: config.fetch,
+      timeoutMs: config.timeoutMs
+    });
+    this.defaultConflictStrategy = config.conflictStrategy ?? "auto";
+    this.cdnBaseUrl = config.cdnBaseUrl;
+  }
+  // ---- Items ----
+  items = {
+    create: async (input) => {
+      const res = await this.transport.request(
+        "POST",
+        "/items",
+        { body: input }
+      );
+      return res.item;
+    },
+    get: async (id) => {
+      const res = await this.transport.request(
+        "GET",
+        `/items/${id}`
+      );
+      return res.item;
+    },
+    list: async (filters) => {
+      return this.transport.request("GET", "/items", {
+        query: filters
+      });
+    },
+    listWithMetadata: async (filters) => {
+      return this.transport.request(
+        "GET",
+        "/items",
+        {
+          query: {
+            ...filters,
+            include: "metadata"
+          }
+        }
+      );
+    },
+    update: async (id, properties, options) => {
+      let version = options?.version;
+      if (version === void 0) {
+        const item = await this.items.get(id);
+        version = item.version;
+      }
+      const strategy = options?.conflict ?? this.defaultConflictStrategy;
+      return handleConflictUpdate(
+        this.transport,
+        id,
+        properties,
+        version,
+        strategy,
+        options?.resolve,
+        options?.thread_id
+      );
+    },
+    delete: async (id) => {
+      await this.transport.request("DELETE", `/items/${id}`);
+    },
+    restore: async (id) => {
+      const res = await this.transport.request(
+        "POST",
+        `/items/${id}/restore`
+      );
+      return res.item;
+    },
+    transition: async (id, state) => {
+      const res = await this.transport.request(
+        "POST",
+        `/items/${id}/transition`,
+        { body: { state } }
+      );
+      return res.item;
+    },
+    versions: async (id) => {
+      const res = await this.transport.request(
+        "GET",
+        `/items/${id}/versions`
+      );
+      return res.versions;
+    },
+    stats: async () => {
+      return this.transport.request(
+        "GET",
+        "/items/stats"
+      );
+    }
+  };
+  // ---- Metadata ----
+  metadata = {
+    get: async (itemId) => {
+      const res = await this.transport.request(
+        "GET",
+        `/items/${itemId}/metadata`
+      );
+      return res.metadata;
+    },
+    set: async (itemId, input) => {
+      const res = await this.transport.request(
+        "PUT",
+        `/items/${itemId}/metadata`,
+        { body: input }
+      );
+      return res.metadata;
+    },
+    merge: async (itemId, input) => {
+      const res = await this.transport.request(
+        "PATCH",
+        `/items/${itemId}/metadata`,
+        { body: input }
+      );
+      return res.metadata;
+    },
+    addTags: async (itemId, tags) => {
+      const res = await this.transport.request(
+        "POST",
+        `/items/${itemId}/tags`,
+        { body: { tags } }
+      );
+      return res.metadata;
+    },
+    removeTag: async (itemId, tag) => {
+      await this.transport.request(
+        "DELETE",
+        `/items/${itemId}/tags/${encodeURIComponent(tag)}`
+      );
+    },
+    getExtensions: async (itemId, namespace) => {
+      if (namespace) {
+        const res2 = await this.transport.request(
+          "GET",
+          `/items/${itemId}/extensions/${encodeURIComponent(namespace)}`
+        );
+        return res2.data ? { [namespace]: res2.data } : {};
+      }
+      const res = await this.transport.request("GET", `/items/${itemId}/extensions`);
+      return res.extensions;
+    },
+    setExtension: async (itemId, namespace, data) => {
+      const res = await this.transport.request(
+        "PUT",
+        `/items/${itemId}/extensions/${encodeURIComponent(namespace)}`,
+        { body: data }
+      );
+      return res.extensions;
+    },
+    deleteExtension: async (itemId, namespace) => {
+      await this.transport.request(
+        "DELETE",
+        `/items/${itemId}/extensions/${encodeURIComponent(namespace)}`
+      );
+    }
+  };
+  // ---- Search ----
+  async search(query, filters) {
+    const res = await this.transport.request(
+      "GET",
+      "/search",
+      { query: { q: query, ...filters } }
+    );
+    return res.results;
+  }
+  // ---- Threads ----
+  threads = {
+    create: async () => {
+      const res = await this.transport.request(
+        "POST",
+        "/threads"
+      );
+      return res.thread;
+    },
+    list: async (filters) => {
+      return this.transport.request(
+        "GET",
+        "/threads",
+        { query: filters }
+      );
+    },
+    get: async (id) => {
+      return this.transport.request(
+        "GET",
+        `/threads/${id}`
+      );
+    },
+    addItem: async (threadId, itemId) => {
+      const res = await this.transport.request(
+        "POST",
+        `/threads/${threadId}/items`,
+        { body: { item_id: itemId } }
+      );
+      return res.item;
+    },
+    removeItem: async (threadId, itemId) => {
+      const res = await this.transport.request(
+        "DELETE",
+        `/threads/${threadId}/items/${itemId}`
+      );
+      return res.item;
+    }
+  };
+  // ---- Blobs ----
+  blobs = {
+    upload: async (data, mimeType) => {
+      const response = await this.transport.rawRequest("POST", "/blobs", {
+        rawBody: data,
+        headers: { "Content-Type": mimeType }
+      });
+      const result = await response.json();
+      if (!response.ok) {
+        this.throwRawError(response.status, result);
+      }
+      return { hash: result.hash };
+    },
+    download: async (hash) => {
+      const response = await this.transport.rawRequest("GET", `/blobs/${hash}`);
+      if (!response.ok) {
+        const body = await response.json();
+        this.throwRawError(response.status, body);
+      }
+      return response.arrayBuffer();
+    },
+    /** Check whether a blob exists without downloading it. */
+    exists: async (hash) => {
+      const cleanHash = hash.startsWith("sha256:") ? hash : `sha256:${hash}`;
+      const response = await this.transport.rawRequest(
+        "HEAD",
+        `/blobs/${cleanHash}`
+      );
+      return response.status === 200;
+    },
+    /** Returns a direct CDN URL if configured, otherwise the API proxy URL. */
+    url: (hash) => {
+      const cleanHash = hash.startsWith("sha256:") ? hash : `sha256:${hash}`;
+      if (this.cdnBaseUrl) {
+        return `${this.cdnBaseUrl}/blobs/${cleanHash}`;
+      }
+      return `${this.apiBaseUrl}/blobs/${cleanHash}`;
+    }
+  };
+  // ---- Types ----
+  types = {
+    list: async () => {
+      return this.transport.request("GET", "/types");
+    },
+    get: async (id) => {
+      return this.transport.request("GET", `/types/${id}`);
+    },
+    register: async (schema) => {
+      return this.transport.request("POST", "/types", {
+        body: schema
+      });
+    },
+    update: async (id, schema) => {
+      return this.transport.request("PUT", `/types/${id}`, {
+        body: schema
+      });
+    },
+    delete: async (id, options) => {
+      const query = options?.force ? "?force=true" : "";
+      await this.transport.request(
+        "DELETE",
+        `/types/${id}${query}`
+      );
+    }
+  };
+  // ---- Keys ----
+  keys = {
+    create: async (input) => {
+      const res = await this.transport.request("POST", "/keys", { body: input });
+      return { id: res.id, key: res.key };
+    },
+    list: async () => {
+      const res = await this.transport.request(
+        "GET",
+        "/keys"
+      );
+      return res.keys;
+    },
+    revoke: async (id) => {
+      await this.transport.request("DELETE", `/keys/${id}`);
+    }
+  };
+  // ---- Webhooks ----
+  webhooks = {
+    create: async (input) => {
+      return this.transport.request("POST", "/webhooks", {
+        body: input
+      });
+    },
+    list: async () => {
+      const res = await this.transport.request(
+        "GET",
+        "/webhooks"
+      );
+      return res.webhooks;
+    },
+    get: async (id) => {
+      return this.transport.request("GET", `/webhooks/${id}`);
+    },
+    update: async (id, input) => {
+      return this.transport.request("PATCH", `/webhooks/${id}`, {
+        body: input
+      });
+    },
+    delete: async (id) => {
+      await this.transport.request(
+        "DELETE",
+        `/webhooks/${id}`
+      );
+    },
+    deliveries: async (id, options) => {
+      const query = options?.limit ? { limit: String(options.limit) } : {};
+      const res = await this.transport.request("GET", `/webhooks/${id}/deliveries`, { query });
+      return res.deliveries;
+    }
+  };
+  // ---- Internal ----
+  throwRawError(status, body) {
+    const parsed = body;
+    const errObj = parsed?.error;
+    const message = errObj?.message ?? `HTTP ${String(status)}`;
+    const details = errObj?.details;
+    switch (status) {
+      case 400:
+        throw new ValidationError(message, details);
+      case 401:
+        throw new UnauthorizedError(message, details);
+      case 403:
+        throw new ForbiddenError(message, details);
+      case 404:
+        throw new NotFoundError(message, details);
+      default:
+        throw new MymeError(
+          errObj?.code ?? "unknown",
+          message,
+          status,
+          details
+        );
+    }
+  }
+};
+export {
+  ConflictError,
+  ForbiddenError,
+  MymeClient,
+  MymeError,
+  NotFoundError,
+  UnauthorizedError,
+  ValidationError
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@mymehq/sdk",
+  "version": "1.0.0",
+  "type": "module",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@mymehq/shared": "workspace:*"
+  },
+  "devDependencies": {
+    "@mymehq/server": "workspace:*",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.2"
+  }
+}