@amerged/ohmyhost-mcp 0.1.10

package/src/packages/contracts/project-context.ts

@@ -0,0 +1,59 @@
+export interface ProjectNotesReceipt {
+  readonly version: number;
+  readonly updated_at: string;
+}
+export interface ProjectContext {
+  readonly project_id: string;
+  readonly generated_at: string;
+  readonly credit_access: "included" | "not_authorized";
+  readonly notes: {
+    readonly version: number;
+    readonly markdown: string;
+    readonly updated_at: string | null;
+  };
+  readonly markdown: string;
+}
+const record = (v: unknown): v is Record<string, unknown> =>
+  typeof v === "object" && v !== null && !Array.isArray(v);
+const timestamp = (v: unknown): v is string =>
+  typeof v === "string" && Number.isFinite(Date.parse(v)) && new Date(v).toISOString() === v;
+const version = (v: unknown) => Number.isInteger(v) && Number(v) >= 0 && Number(v) <= 2147483647;
+const bounded = (v: unknown, lines: number, bytes: number): v is string =>
+  typeof v === "string" &&
+  !/[\r\u2028\u2029]/u.test(v) &&
+  !/\p{Cc}/u.test(v.replace(/[\n\t]/gu, "")) &&
+  v.split("\n").length <= lines &&
+  new TextEncoder().encode(v).length <= bytes;
+export function assertProjectNotesReceipt(v: unknown): asserts v is ProjectNotesReceipt {
+  if (
+    !record(v) ||
+    Object.keys(v).sort().join(",") !== "updated_at,version" ||
+    !version(v["version"]) ||
+    v["version"] === 0 ||
+    !timestamp(v["updated_at"])
+  )
+    throw new TypeError("Invalid project notes receipt");
+}
+export function assertProjectContext(v: unknown): asserts v is ProjectContext {
+  if (
+    !record(v) ||
+    Object.keys(v).sort().join(",") !== "credit_access,generated_at,markdown,notes,project_id" ||
+    typeof v["project_id"] !== "string" ||
+    !/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/u.test(v["project_id"]) ||
+    !timestamp(v["generated_at"]) ||
+    !["included", "not_authorized"].includes(String(v["credit_access"])) ||
+    !bounded(v["markdown"], 500, 32768)
+  )
+    throw new TypeError("Invalid project context");
+  const notes = v["notes"];
+  if (
+    !record(notes) ||
+    Object.keys(notes).sort().join(",") !== "markdown,updated_at,version" ||
+    !version(notes["version"]) ||
+    !bounded(notes["markdown"], 250, 16384) ||
+    (notes["version"] === 0
+      ? notes["updated_at"] !== null || notes["markdown"] !== ""
+      : !timestamp(notes["updated_at"]))
+  )
+    throw new TypeError("Invalid project notes");
+}

package/src/packages/contracts/project-exports.ts

@@ -0,0 +1,102 @@
+import { publicOperationFailure, type PublicOperationFailure } from "./operation-failure.js";
+export interface ProjectExport {
+  readonly id: string;
+  readonly project_id: string;
+  readonly state: "queued" | "running" | "succeeded" | "failed" | "cancelled";
+  readonly requested_at: string;
+  readonly next_request_at: string;
+  readonly next_poll_after_seconds: 5 | null;
+  readonly error: PublicOperationFailure | null;
+  readonly archive: {
+    readonly bytes: number;
+    readonly sha256: string;
+    readonly sql_files: readonly string[];
+    readonly captured_at: string;
+    readonly expires_at: string;
+    readonly download_url: string | null;
+    readonly download_expires_at: string | null;
+  } | null;
+}
+/** The public export shape carries no job password, source URL or permanent storage credential. */
+export function assertProjectExport(value: unknown): asserts value is ProjectExport {
+  if (
+    !record(value) ||
+    Object.keys(value).sort().join(",") !==
+      "archive,error,id,next_poll_after_seconds,next_request_at,project_id,requested_at,state" ||
+    typeof value["id"] !== "string" ||
+    !id.test(value["id"]) ||
+    typeof value["project_id"] !== "string" ||
+    !id.test(value["project_id"]) ||
+    !["queued", "running", "succeeded", "failed", "cancelled"].includes(String(value["state"])) ||
+    !timestamp(value["requested_at"]) ||
+    !timestamp(value["next_request_at"])
+  )
+    invalid();
+  const active = value["state"] === "queued" || value["state"] === "running";
+  if (value["next_poll_after_seconds"] !== (active ? 5 : null)) invalid();
+  if (value["state"] === "failed") {
+    const error = value["error"];
+    if (
+      !record(error) ||
+      Object.keys(error).sort().join(",") !== "code,message,retryable,suggested_action" ||
+      typeof error["code"] !== "string"
+    )
+      invalid();
+    const expected = publicOperationFailure(error["code"]);
+    for (const key of Object.keys(expected) as (keyof PublicOperationFailure)[])
+      if (error[key] !== expected[key]) invalid();
+  } else if (value["error"] !== null) invalid();
+  const archive = value["archive"];
+  if (archive === null) {
+    if (value["state"] === "succeeded") invalid();
+    return;
+  }
+  if (
+    value["state"] !== "succeeded" ||
+    !record(archive) ||
+    Object.keys(archive).sort().join(",") !==
+      "bytes,captured_at,download_expires_at,download_url,expires_at,sha256,sql_files" ||
+    !Number.isSafeInteger(archive["bytes"]) ||
+    Number(archive["bytes"]) < 1 ||
+    Number(archive["bytes"]) > 536870912 ||
+    typeof archive["sha256"] !== "string" ||
+    !/^sha256:[a-f0-9]{64}$/u.test(archive["sha256"]) ||
+    !['["dev.sql"]', '["prod.sql"]', '["dev.sql","prod.sql"]', '["shared.sql"]'].includes(
+      JSON.stringify(archive["sql_files"]),
+    ) ||
+    !timestamp(archive["captured_at"]) ||
+    !timestamp(archive["expires_at"])
+  )
+    invalid();
+  if (archive["download_url"] === null) {
+    if (archive["download_expires_at"] !== null) invalid();
+    return;
+  }
+  if (
+    typeof archive["download_url"] !== "string" ||
+    !timestamp(archive["download_expires_at"]) ||
+    Date.parse(archive["download_expires_at"]) > Date.parse(archive["expires_at"])
+  )
+    invalid();
+  let url;
+  try {
+    url = new URL(archive["download_url"]);
+  } catch {
+    invalid();
+  }
+  if (url.protocol !== "https:" || url.username || url.password || url.hash) invalid();
+}
+const id = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/u;
+function record(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function timestamp(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    Number.isFinite(Date.parse(value)) &&
+    new Date(value).toISOString() === value
+  );
+}
+function invalid(): never {
+  throw new TypeError("Project export response is invalid");
+}

package/src/packages/contracts/user-api-keys.ts

@@ -0,0 +1,98 @@
+export interface UserApiKey {
+  id: string;
+  organization_id: string;
+  name: string;
+  obfuscated_value: string;
+  permissions: string[];
+  expires_at: string | null;
+  created_at: string;
+  last_used_at: string | null;
+}
+export interface UserApiKeyCreation {
+  request_id: string;
+  replayed: boolean;
+  key: UserApiKey;
+  value: string | null;
+}
+export interface UserApiKeyPage {
+  data: UserApiKey[];
+  next_cursor: string | null;
+}
+export const USER_API_KEY_ID = /^api_key_[A-Za-z0-9_]{1,120}$/u;
+const ulid = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/u;
+
+function object(value: unknown, fields: string): Record<string, unknown> {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    Object.keys(value).sort().join(",") !== fields.split(",").sort().join(",")
+  )
+    throw new TypeError("Invalid user key response");
+  return value as Record<string, unknown>;
+}
+function date(value: unknown): boolean {
+  return (
+    typeof value === "string" &&
+    Number.isFinite(Date.parse(value)) &&
+    new Date(value).toISOString() === value
+  );
+}
+export function parseUserApiKey(value: unknown): UserApiKey {
+  const v = object(
+    value,
+    "id,organization_id,name,obfuscated_value,permissions,expires_at,created_at,last_used_at",
+  );
+  if (
+    typeof v["id"] !== "string" ||
+    !USER_API_KEY_ID.test(v["id"]) ||
+    typeof v["organization_id"] !== "string" ||
+    !ulid.test(v["organization_id"]) ||
+    typeof v["name"] !== "string" ||
+    v["name"].trim() !== v["name"] ||
+    v["name"].length < 1 ||
+    v["name"].length > 128 ||
+    /\p{Cc}/u.test(v["name"]) ||
+    typeof v["obfuscated_value"] !== "string" ||
+    !/^sk_(?:\.\.\.|…)[A-Za-z0-9_-]{1,12}$/u.test(v["obfuscated_value"]) ||
+    !Array.isArray(v["permissions"]) ||
+    v["permissions"].length > 100 ||
+    new Set(v["permissions"]).size !== v["permissions"].length ||
+    v["permissions"].some(
+      (p: unknown) => typeof p !== "string" || !/^[A-Za-z0-9_.*:-]{1,128}$/u.test(p),
+    ) ||
+    !date(v["created_at"]) ||
+    (v["expires_at"] !== null && !date(v["expires_at"])) ||
+    (v["last_used_at"] !== null && !date(v["last_used_at"]))
+  )
+    throw new TypeError("Invalid user key metadata");
+  return v as unknown as UserApiKey;
+}
+export function parseUserApiKeyCreation(value: unknown): UserApiKeyCreation {
+  const v = object(value, "request_id,replayed,key,value");
+  if (
+    typeof v["request_id"] !== "string" ||
+    !ulid.test(v["request_id"]) ||
+    typeof v["replayed"] !== "boolean" ||
+    (v["replayed"]
+      ? v["value"] !== null
+      : typeof v["value"] !== "string" || !/^sk_[A-Za-z0-9_-]{20,128}$/u.test(v["value"]))
+  )
+    throw new TypeError("Invalid user key creation");
+  parseUserApiKey(v["key"]);
+  return v as unknown as UserApiKeyCreation;
+}
+export function parseUserApiKeyPage(value: unknown): UserApiKeyPage {
+  const v = object(value, "data,next_cursor");
+  if (
+    !Array.isArray(v["data"]) ||
+    v["data"].length > 20 ||
+    (v["next_cursor"] !== null &&
+      (typeof v["next_cursor"] !== "string" || !USER_API_KEY_ID.test(v["next_cursor"])))
+  )
+    throw new TypeError("Invalid user key page");
+  const keys = v["data"].map(parseUserApiKey);
+  if (new Set(keys.map((key) => key.id)).size !== keys.length)
+    throw new TypeError("Duplicate user keys");
+  return v as unknown as UserApiKeyPage;
+}

package/src/packages/sdk-ts/generated/client/client.gen.ts

@@ -0,0 +1,277 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { createSseClient } from "../core/serverSentEvents.gen.js";
+import type { HttpMethod } from "../core/types.gen.js";
+import { getValidRequestBody } from "../core/utils.gen.js";
+import type { Client, Config, RequestOptions, ResolvedRequestOptions } from "./types.gen.js";
+import {
+  buildUrl,
+  createConfig,
+  createInterceptors,
+  getParseAs,
+  mergeConfigs,
+  mergeHeaders,
+  setAuthParams,
+} from "./utils.gen.js";
+
+type ReqInit = Omit<RequestInit, "body" | "headers"> & {
+  body?: any;
+  headers: ReturnType<typeof mergeHeaders>;
+};
+
+export const createClient = (config: Config = {}): Client => {
+  let _config = mergeConfigs(createConfig(), config);
+
+  const getConfig = (): Config => ({ ..._config });
+
+  const setConfig = (config: Config): Config => {
+    _config = mergeConfigs(_config, config);
+    return getConfig();
+  };
+
+  const interceptors = createInterceptors<Request, Response, unknown, ResolvedRequestOptions>();
+
+  const beforeRequest = async <
+    TData = unknown,
+    TResponseStyle extends "data" | "fields" = "fields",
+    ThrowOnError extends boolean = boolean,
+    Url extends string = string,
+  >(
+    options: RequestOptions<TData, TResponseStyle, ThrowOnError, Url>,
+  ) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: undefined as string | undefined,
+    };
+
+    if (opts.security) {
+      await setAuthParams(opts);
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+
+    if (opts.body !== undefined && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body) as string | undefined;
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.body === undefined || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type");
+    }
+
+    const resolvedOpts = opts as typeof opts &
+      ResolvedRequestOptions<TResponseStyle, ThrowOnError, Url>;
+    const url = buildUrl(resolvedOpts);
+
+    return { opts: resolvedOpts, url };
+  };
+
+  const request: Client["request"] = async (options) => {
+    const throwOnError = options.throwOnError ?? _config.throwOnError;
+    const responseStyle = options.responseStyle ?? _config.responseStyle;
+
+    let request: Request | undefined;
+    let response: Response | undefined;
+
+    try {
+      const { opts, url } = await beforeRequest(options);
+      const requestInit: ReqInit = {
+        redirect: "follow",
+        ...opts,
+        body: getValidRequestBody(opts),
+      };
+
+      request = new Request(url, requestInit);
+
+      for (const fn of interceptors.request.fns) {
+        if (fn) {
+          request = await fn(request, opts);
+        }
+      }
+
+      // fetch must be assigned here, otherwise it would throw the error:
+      // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+      const _fetch = opts.fetch!;
+
+      response = await _fetch(request);
+
+      for (const fn of interceptors.response.fns) {
+        if (fn) {
+          response = await fn(response, request, opts);
+        }
+      }
+
+      const result = {
+        request,
+        response,
+      };
+
+      if (response.ok) {
+        const parseAs =
+          (opts.parseAs === "auto"
+            ? getParseAs(response.headers.get("Content-Type"))
+            : opts.parseAs) ?? "json";
+
+        if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+          let emptyData: any;
+          switch (parseAs) {
+            case "arrayBuffer":
+            case "blob":
+            case "text":
+              emptyData = await response[parseAs]();
+              break;
+            case "formData":
+              emptyData = new FormData();
+              break;
+            case "stream":
+              emptyData = response.body;
+              break;
+            case "json":
+            default:
+              emptyData = {};
+              break;
+          }
+          return opts.responseStyle === "data"
+            ? emptyData
+            : {
+                data: emptyData,
+                ...result,
+              };
+        }
+
+        let data: any;
+        switch (parseAs) {
+          case "arrayBuffer":
+          case "blob":
+          case "formData":
+          case "text":
+            data = await response[parseAs]();
+            break;
+          case "json": {
+            // Some servers return 200 with no Content-Length and empty body.
+            // response.json() would throw; read as text and parse if non-empty.
+            const text = await response.text();
+            data = text ? JSON.parse(text) : {};
+            break;
+          }
+          case "stream":
+            return opts.responseStyle === "data"
+              ? response.body
+              : {
+                  data: response.body,
+                  ...result,
+                };
+        }
+
+        if (parseAs === "json") {
+          if (opts.responseValidator) {
+            await opts.responseValidator(data);
+          }
+
+          if (opts.responseTransformer) {
+            data = await opts.responseTransformer(data);
+          }
+        }
+
+        return opts.responseStyle === "data"
+          ? data
+          : {
+              data,
+              ...result,
+            };
+      }
+
+      const textError = await response.text();
+      let jsonError: unknown;
+
+      try {
+        jsonError = JSON.parse(textError);
+      } catch {
+        // noop
+      }
+
+      throw jsonError ?? textError;
+    } catch (error) {
+      let finalError = error;
+
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError = await fn(finalError, response, request, options as ResolvedRequestOptions);
+        }
+      }
+
+      finalError = finalError || {};
+
+      if (throwOnError) {
+        throw finalError;
+      }
+
+      // TODO: we probably want to return error and improve types
+      return responseStyle === "data"
+        ? undefined
+        : {
+            error: finalError,
+            request,
+            response,
+          };
+    }
+  };
+
+  const makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
+    request({ ...options, method });
+
+  const makeSseFn = (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body as BodyInit | null | undefined,
+      method,
+      onRequest: async (url, init) => {
+        let request = new Request(url, init);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request = await fn(request, opts);
+          }
+        }
+        return request;
+      },
+      serializedBody: getValidRequestBody(opts) as BodyInit | null | undefined,
+      url,
+    });
+  };
+
+  const _buildUrl: Client["buildUrl"] = (options) => buildUrl({ ..._config, ...options });
+
+  return {
+    buildUrl: _buildUrl,
+    connect: makeMethodFn("CONNECT"),
+    delete: makeMethodFn("DELETE"),
+    get: makeMethodFn("GET"),
+    getConfig,
+    head: makeMethodFn("HEAD"),
+    interceptors,
+    options: makeMethodFn("OPTIONS"),
+    patch: makeMethodFn("PATCH"),
+    post: makeMethodFn("POST"),
+    put: makeMethodFn("PUT"),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn("CONNECT"),
+      delete: makeSseFn("DELETE"),
+      get: makeSseFn("GET"),
+      head: makeSseFn("HEAD"),
+      options: makeSseFn("OPTIONS"),
+      patch: makeSseFn("PATCH"),
+      post: makeSseFn("POST"),
+      put: makeSseFn("PUT"),
+      trace: makeSseFn("TRACE"),
+    },
+    trace: makeMethodFn("TRACE"),
+  } as Client;
+};

package/src/packages/sdk-ts/generated/client/index.ts

@@ -0,0 +1,27 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type { Auth } from "../core/auth.gen.js";
+export type { QuerySerializerOptions } from "../core/bodySerializer.gen.js";
+export {
+  formDataBodySerializer,
+  jsonBodySerializer,
+  urlSearchParamsBodySerializer,
+} from "../core/bodySerializer.gen.js";
+export { buildClientParams } from "../core/params.gen.js";
+export { serializeQueryKeyValue } from "../core/queryKeySerializer.gen.js";
+export type { ServerSentEventsResult } from "../core/serverSentEvents.gen.js";
+export type { ClientMeta } from "../core/types.gen.js";
+export { createClient } from "./client.gen.js";
+export type {
+  Client,
+  ClientOptions,
+  Config,
+  CreateClientConfig,
+  Options,
+  RequestOptions,
+  RequestResult,
+  ResolvedRequestOptions,
+  ResponseStyle,
+  TDataShape,
+} from "./types.gen.js";
+export { createConfig, mergeHeaders } from "./utils.gen.js";