@amerged/ohmyhost-mcp 0.1.38 → 0.1.39

package/src/packages/postgres-bridge/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/src/packages/postgres-bridge/NOTICE

@@ -0,0 +1 @@
+PostgreSQL WebSocket bridge and authentication prelude handling adapted from cloudflare-postgres packages/cli, commit e05d9102c840e283602272ed0e16a95be3e3b8ea. Upstream license: Apache-2.0.

package/src/packages/postgres-bridge/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@ohmyhost/postgres-bridge",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "license": "Apache-2.0",
+  "description": "Bounded loopback PostgreSQL transport to verified PGCF WSS; no provider authority",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "typecheck": "tsc --project tsconfig.json --noEmit --incremental --tsBuildInfoFile typecheck.tsbuildinfo",
+    "test": "vitest run --root ../.. packages/postgres-bridge/test"
+  },
+  "dependencies": {
+    "ws": "8.22.0"
+  },
+  "devDependencies": {
+    "@types/ws": "8.18.2"
+  }
+}

package/src/packages/postgres-bridge/src/auth.ts

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: Apache-2.0
+// Adapted from cloudflare-postgres packages/cli at e05d9102c840e283602272ed0e16a95be3e3b8ea.
+import { Transform } from "node:stream";
+import type { TransformCallback } from "node:stream";
+
+export const AUTH_BYTES = 64 * 1024;
+const SSL_REQUEST = 80877103;
+const GSS_REQUEST = 80877104;
+
+export class BackendAuthentication extends Transform {
+  private frame = Buffer.alloc(AUTH_BYTES);
+  private length = 0;
+  private target = 5;
+  private offered = false;
+  private typed = false;
+  private preludes = 0;
+  authenticated = false;
+
+  constructor() {
+    super({ highWaterMark: AUTH_BYTES });
+  }
+
+  expectPrelude(): void {
+    if (this.typed || this.authenticated || this.preludes >= 2)
+      throw new Error("invalid_auth_prelude");
+    this.preludes++;
+  }
+
+  private authentication(frame: Buffer): Buffer {
+    if (frame.length < 9) throw new Error("invalid_auth_frame");
+    const code = frame.readUInt32BE(5);
+    if (code === 3) throw new Error("cleartext_auth_refused");
+    if (code !== 0 && code !== 10 && code !== 11 && code !== 12)
+      throw new Error("unsupported_authentication");
+    if (code === 0) {
+      if (frame.length !== 9) throw new Error("invalid_auth_frame");
+      this.authenticated = true;
+      return frame;
+    }
+    if (code !== 10) return frame;
+    if (this.offered) throw new Error("duplicate_sasl_offer");
+    this.offered = true;
+    const bytes = frame.subarray(9);
+    if (bytes.length < 2 || bytes.at(-1) !== 0 || bytes.at(-2) !== 0)
+      throw new Error("invalid_sasl_offer");
+    const names = bytes.subarray(0, -2).toString("ascii").split("\0");
+    if (
+      bytes.some((value) => value > 127) ||
+      names.length > 16 ||
+      names.some((name) => !/^[A-Z0-9_-]{1,128}$/.test(name)) ||
+      new Set(names).size !== names.length ||
+      !names.includes("SCRAM-SHA-256")
+    )
+      throw new Error("invalid_sasl_offer");
+    const retained = names.filter((name) => name !== "SCRAM-SHA-256-PLUS");
+    if (retained.length === names.length) return frame;
+    const mechanisms = Buffer.from(retained.join("\0") + "\0\0");
+    const rewritten = Buffer.alloc(9 + mechanisms.length);
+    rewritten[0] = 0x52;
+    rewritten.writeUInt32BE(8 + mechanisms.length, 1);
+    rewritten.writeUInt32BE(10, 5);
+    mechanisms.copy(rewritten, 9);
+    return rewritten;
+  }
+
+  override _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void {
+    try {
+      let offset = 0;
+      while (offset < chunk.length) {
+        if (this.authenticated) {
+          this.push(chunk.subarray(offset));
+          break;
+        }
+        if (this.preludes && this.length === 0) {
+          if (chunk[offset] !== 0x4e) throw new Error("invalid_auth_prelude");
+          this.preludes--;
+          this.push(chunk.subarray(offset, ++offset));
+          continue;
+        }
+        this.typed = true;
+        const count = Math.min(this.target - this.length, chunk.length - offset);
+        chunk.copy(this.frame, this.length, offset, offset + count);
+        this.length += count;
+        offset += count;
+        if (this.length !== this.target) continue;
+        if (this.target === 5) {
+          const length = this.frame.readUInt32BE(1);
+          if (length < 4 || length + 1 > AUTH_BYTES) throw new Error("invalid_auth_frame");
+          this.target = length + 1;
+          if (this.length !== this.target) continue;
+        }
+        const frame = Buffer.from(this.frame.subarray(0, this.target));
+        this.push(frame[0] === 0x52 ? this.authentication(frame) : frame);
+        this.length = 0;
+        this.target = 5;
+      }
+      callback();
+    } catch (error) {
+      callback(error instanceof Error ? error : new Error("invalid_auth_frame"));
+    }
+  }
+
+  override _flush(callback: TransformCallback): void {
+    callback(this.length || this.preludes ? new Error("truncated_auth_frame") : undefined);
+  }
+}
+
+export class FrontendPrelude extends Transform {
+  private header = Buffer.alloc(8);
+  private length = 0;
+  private startup = false;
+  private count = 0;
+  private backend: BackendAuthentication;
+
+  constructor(backend: BackendAuthentication) {
+    super({ highWaterMark: AUTH_BYTES });
+    this.backend = backend;
+  }
+
+  override _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void {
+    try {
+      let offset = 0;
+      while (offset < chunk.length) {
+        if (this.startup || this.backend.authenticated) {
+          if (this.length) {
+            this.push(Buffer.from(this.header.subarray(0, this.length)));
+            this.length = 0;
+          }
+          this.push(chunk.subarray(offset));
+          break;
+        }
+        const count = Math.min(8 - this.length, chunk.length - offset);
+        chunk.copy(this.header, this.length, offset, offset + count);
+        this.length += count;
+        offset += count;
+        if (this.length !== 8) continue;
+        const code = this.header.readUInt32BE(4);
+        if (code === SSL_REQUEST || code === GSS_REQUEST) {
+          if (this.header.readUInt32BE(0) !== 8 || ++this.count > 2)
+            throw new Error("invalid_frontend_prelude");
+          this.backend.expectPrelude();
+        } else this.startup = true;
+        this.push(Buffer.from(this.header));
+        this.length = 0;
+      }
+      callback();
+    } catch (error) {
+      callback(error instanceof Error ? error : new Error("invalid_frontend_prelude"));
+    }
+  }
+
+  override _flush(callback: TransformCallback): void {
+    if (this.backend.authenticated && this.length) {
+      this.push(Buffer.from(this.header.subarray(0, this.length)));
+      this.length = 0;
+    }
+    callback(this.length ? new Error("truncated_frontend_prelude") : undefined);
+  }
+}

package/src/packages/postgres-bridge/src/bridge.ts

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: Apache-2.0
+// Adapted from cloudflare-postgres packages/cli at e05d9102c840e283602272ed0e16a95be3e3b8ea.
+import { createServer } from "node:net";
+import type { AddressInfo, Socket } from "node:net";
+import type { Duplex } from "node:stream";
+import WebSocket, { createWebSocketStream } from "ws";
+import { upstreamUrl, validateOptions } from "./options.js";
+import type { ConnectOptions } from "./options.js";
+import { BackendAuthentication, FrontendPrelude } from "./auth.js";
+
+export const STREAM_BYTES = 64 * 1024;
+export const MESSAGE_BYTES = 1024 * 1024;
+export const CLIENT_LIMIT = 16;
+// The edge answers the upgrade only after a sleeping database is admitted, within its 60 s
+// admission deadline (ADMISSION_DEADLINE_MS in @pgcf/contracts); the handshake waits for that plus margin.
+export const HANDSHAKE_MS = 65_000;
+export const FRAGMENT_LIMIT = 128;
+export const HALF_CLOSE_MS = 10_000;
+
+export interface Session {
+  local: Socket;
+  upstream: WebSocket;
+  stream: Duplex;
+  authentication: BackendAuthentication;
+  frontend: FrontendPrelude;
+}
+export type Connector = (url: string) => WebSocket;
+export const UPSTREAM_OPTIONS: Readonly<WebSocket.ClientOptions> = Object.freeze({
+  rejectUnauthorized: true,
+  followRedirects: false,
+  perMessageDeflate: false,
+  autoPong: false,
+  allowSynchronousEvents: false,
+  maxFragments: FRAGMENT_LIMIT,
+  maxBufferedChunks: 256,
+  maxPayload: MESSAGE_BYTES,
+  handshakeTimeout: HANDSHAKE_MS,
+});
+export const connectUpstream: Connector = (url) => {
+  if (new URL(url).protocol !== "wss:") throw new Error("invalid_endpoint");
+  return new WebSocket(url, UPSTREAM_OPTIONS);
+};
+
+export interface Bridge {
+  readonly host: string;
+  readonly port: number;
+  readonly clients: number;
+  close(): Promise<void>;
+}
+export interface BridgeHooks {
+  connect?: Connector;
+  session?: (value: Session) => void;
+  disconnected?: () => void;
+}
+
+export async function startBridge(raw: ConnectOptions, hooks: BridgeHooks = {}): Promise<Bridge> {
+  const options = validateOptions(raw);
+  const sessions = new Set<Session>();
+  const endings = new Set<Promise<void>>();
+  let closing: Promise<void> | undefined;
+  const server = createServer({ highWaterMark: STREAM_BYTES, allowHalfOpen: true }, (local) => {
+    local.on("error", () => {});
+    if (closing || sessions.size >= CLIENT_LIMIT) {
+      local.destroy();
+      return;
+    }
+    let upstream: WebSocket;
+    try {
+      upstream = (hooks.connect ?? connectUpstream)(upstreamUrl(options));
+    } catch {
+      local.destroy();
+      return;
+    }
+    const stream = createWebSocketStream(upstream, {
+      highWaterMark: STREAM_BYTES,
+    });
+    const authentication = new BackendAuthentication();
+    const frontend = new FrontendPrelude(authentication);
+    const session = { local, upstream, stream, authentication, frontend };
+    sessions.add(session);
+    const ended = new Promise<void>((resolve) => upstream.once("close", () => resolve()));
+    endings.add(ended);
+    void ended.then(() => endings.delete(ended));
+    let finished = false;
+    let halfCloseTimer: ReturnType<typeof setTimeout> | undefined;
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      if (halfCloseTimer) clearTimeout(halfCloseTimer);
+      local.unpipe(frontend);
+      frontend.unpipe(stream);
+      stream.unpipe(authentication);
+      authentication.unpipe(local);
+      local.destroy();
+      frontend.destroy();
+      authentication.destroy();
+      stream.destroy();
+      upstream.terminate();
+      sessions.delete(session);
+      hooks.disconnected?.();
+    };
+    stream.on("error", finish);
+    authentication.on("error", finish);
+    frontend.on("error", finish);
+    upstream.on("error", finish);
+    local.once("error", finish);
+    local.once("close", finish);
+    local.once("end", () => {
+      if (finished) return;
+      // WebSocket has no half-close: retain its readable side while queued bytes drain.
+      halfCloseTimer = setTimeout(
+        finish,
+        HALF_CLOSE_MS + (upstream.readyState === WebSocket.CONNECTING ? HANDSHAKE_MS : 0),
+      );
+    });
+    stream.once("close", finish);
+    upstream.once("close", () => {
+      // Let the readable stream flush admitted bytes before ending local TCP.
+      if (local.destroyed) finish();
+    });
+    authentication.once("end", () => local.end());
+    upstream.prependListener("message", (_data, binary) => {
+      if (!binary) finish();
+    });
+    upstream.on("ping", (data) => {
+      if (upstream.bufferedAmount >= STREAM_BYTES) {
+        finish();
+        return;
+      }
+      upstream.pong(data, true, (error) => {
+        if (error) finish();
+      });
+    });
+    local.setNoDelay(true);
+    hooks.session?.(session);
+    local.pipe(frontend);
+    frontend.pipe(stream, { end: false });
+    stream.pipe(authentication).pipe(local);
+  });
+  server.maxConnections = CLIENT_LIMIT;
+  await new Promise<void>((resolve, reject) => {
+    const failed = () => reject(new Error("listener_failed"));
+    server.once("error", failed);
+    server.listen(options.port, [127, 0, 0, 1].join("."), () => {
+      server.removeListener("error", failed);
+      resolve();
+    });
+  });
+  const address = server.address() as AddressInfo;
+  const bridge: Bridge = {
+    host: address.address,
+    port: address.port,
+    get clients() {
+      return sessions.size;
+    },
+    close() {
+      closing ??= (async () => {
+        const listener = new Promise<void>((resolve) => server.close(() => resolve()));
+        for (const session of [...sessions]) session.local.destroy();
+        await listener;
+        await Promise.all([...endings]);
+      })();
+      return closing;
+    },
+  };
+  server.on("error", bridge.close);
+  return bridge;
+}

package/src/packages/postgres-bridge/src/index.ts

@@ -0,0 +1,2 @@
+export { startBridge, type Bridge } from "./bridge.js";
+export { validateOptions, type ConnectOptions } from "./options.js";

package/src/packages/postgres-bridge/src/options.ts

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+const isDatabaseId = (value: string) => /^[a-z][a-z0-9]{19}$/u.test(value);
+const isRoleName = (value: string) => /^[a-z][a-z0-9_]{0,62}$/u.test(value);
+
+export interface ConnectOptions {
+  endpoint: string;
+  database: string;
+  user: string;
+  port: number;
+}
+
+export function validateOptions(value: ConnectOptions): ConnectOptions {
+  let endpoint: URL;
+  try {
+    endpoint = new URL(value.endpoint);
+  } catch {
+    throw new Error("invalid_endpoint");
+  }
+  if (
+    endpoint.protocol !== "wss:" ||
+    !endpoint.hostname ||
+    endpoint.username ||
+    endpoint.password ||
+    endpoint.search ||
+    endpoint.hash ||
+    endpoint.pathname !== "/" ||
+    value.endpoint.length > 2048 ||
+    /[\s\\?#@]/.test(value.endpoint)
+  )
+    throw new Error("invalid_endpoint");
+  if (!isDatabaseId(value.database)) throw new Error("invalid_database");
+  if (!isRoleName(value.user)) throw new Error("invalid_user");
+  if (!Number.isInteger(value.port) || value.port < 0 || value.port > 65535)
+    throw new Error("invalid_port");
+  return {
+    endpoint: endpoint.href,
+    database: value.database,
+    user: value.user,
+    port: value.port,
+  };
+}
+
+export function upstreamUrl(options: ConnectOptions): string {
+  const url = new URL(options.endpoint);
+  url.pathname = "/v2";
+  url.searchParams.set("database", options.database);
+  url.searchParams.set("user", options.user);
+  return url.href;
+}

package/src/packages/sdk-ts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohmyhost/sdk-ts",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -360,6 +360,7 @@ export type {
   FeedbackStatus,
   FeedbackSubmission,
   FeedbackUpdate,
+  FixedDatabaseCompute,
   FunctionRun,
   FunctionRunPage,
   GetAccountProfileData,

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

@@ -4441,18 +4441,21 @@ export const getDatabaseCompute = <ThrowOnError extends boolean = true>(
 };
 
 /**
- * Select standard or Paid performance database compute
+ * Select database memory and included storage
  *
- * Requires project-write access and explicit confirmation. Reads the organization plan at acceptance (Free 0.25 CU/1 GB/60 idle seconds or Paid 0.5 CU/2 GB/60 idle seconds). Changes the existing database in place without copying or resetting data. Shared Dev/Prod data changes both environments. A brief connection interruption is possible. Poll the returned operation every 60 seconds; do not submit a second change while it runs. Completion requires actual provider settings and settled operations. Actual CU consumption remains metered. Performance requires effective Paid access and an active rate; it selects fixed 1 CU/4 GB/300 idle seconds at 2.5 times Paid-standard database compute credits per equal active minute. Only database compute changes price. Raw CU-second measurements are preserved; mixed or uncertain transition hours waive the premium. Returning to standard restores the effective plan size.
+ * Requires project-write access and explicit confirmation. Select 256, 512, 1024, 2048 or 4096 MiB RAM; Free permits only 256 MiB. Included total storage is respectively 500, 1024, 2048, 4096 or 8192 MiB, including PostgreSQL and WAL. Seven-day backups are included. Each 256 MiB costs 10 credits per active hour, prorated by time; sleeping costs no active RAM credits. Shared Dev/Prod data changes both environments. A smaller volume requires a separate data migration and is refused here. A brief connection interruption is possible. Poll the original operation until observed completion. The legacy profile input is accepted only for databases still on the transitional provider; it does not imply PGCF autoscaling.
  */
 export const changeDatabaseCompute = <ThrowOnError extends boolean = true>(
   parameters: {
     "X-Request-Id"?: string;
     "Idempotency-Key": string;
     project_id: Ulid;
-    environment: "dev" | "prod";
-    profile: "standard" | "performance";
-    confirm: true;
+    body: unknown & {
+      environment: "dev" | "prod";
+      profile?: "standard" | "performance";
+      memory_mib?: 256 | 512 | 1024 | 2048 | 4096;
+      confirm: true;
+    };
   },
   options?: Options<never, ThrowOnError>,
 ): RequestResult<
@@ -4469,9 +4472,7 @@ export const changeDatabaseCompute = <ThrowOnError extends boolean = true>(
           { in: "headers", key: "X-Request-Id" },
           { in: "headers", key: "Idempotency-Key" },
           { in: "path", key: "project_id" },
-          { in: "body", key: "environment" },
-          { in: "body", key: "profile" },
-          { in: "body", key: "confirm" },
+          { key: "body", map: "body" },
         ],
       },
     ],