@amerged/ohmyhost-cli 0.1.37 → 0.1.39

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.37",
+  "version": "0.1.39",
   "private": true,
   "type": "module",
   "exports": {
@@ -14,7 +14,7 @@
     "build": "tsc --project tsconfig.build.json",
     "check": "pnpm --dir ../.. sdk-ts:check",
     "generate": "pnpm --dir ../.. sdk-ts:generate",
-    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "typecheck": "tsc --project tsconfig.json --noEmit --incremental --tsBuildInfoFile typecheck.tsbuildinfo",
     "test": "pnpm run check && vitest run --root ../.. packages/sdk-ts"
   },
   "license": "Apache-2.0"

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" },
         ],
       },
     ],

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

@@ -376,9 +376,9 @@ export type PublishedCreditRateCard = {
     unit: string;
     units_per_charge: string;
     /**
-     * Provider list-cost basis for units_per_charge, in USD micro-units (1000000 equals 1 USD), before shared allowances and discounts.
+     * Provider list-cost basis for units_per_charge, in USD micro-units (1000000 equals 1 USD), before shared allowances and discounts. Null for the PGCF RAM tariff means node infrastructure costs are tracked separately and are not allocated to this customer rate; null never means zero cost.
      */
-    provider_cost_micros: string;
+    provider_cost_micros: string | null;
     credit_micros: CreditMicros;
   }>;
 };
@@ -894,13 +894,29 @@ export type ProjectDatabaseAccessRequest = {
   label?: string | null;
 };
 
-export type ProjectDatabaseAccess = {
+export type ProjectDatabaseAccess = (
+  | {
+      database?: "neondb";
+    }
+  | {
+      database?: unknown;
+    }
+) & {
   access_id: Ulid;
   environment: "dev" | "prod";
   mode: "read" | "write";
   role_name: string;
   host: string;
-  database: "neondb";
+  /**
+   * neondb for a transitional Neon credential; the exact 20-character PGCF database identity for WSS.
+   */
+  database: string;
+  provider?: "pgcf";
+  transport?: "wss";
+  /**
+   * Verified WSS origin ending in / and matching host. The local bridge adds /v2 and the bound database and user; no public PostgreSQL TCP endpoint.
+   */
+  websocket_url?: string;
   label: string | null;
   state: "active" | "expired" | "revoked";
   issued_at: string;
@@ -909,13 +925,41 @@ export type ProjectDatabaseAccess = {
   revocation_reason: "principal" | "expired" | "budget" | "creation_failed" | "data_change" | null;
 };
 
-export type ProjectDatabaseAccessCredential = ProjectDatabaseAccess & {
+export type ProjectDatabaseAccessCredential = (
+  | {
+      database?: "neondb";
+    }
+  | {
+      database?: unknown;
+    }
+) & {
+  access_id: Ulid;
+  environment: "dev" | "prod";
+  mode: "read" | "write";
+  role_name: string;
+  host: string;
   /**
-   * Returned exactly once. Use it immediately and never store it in files, notes or source.
+   * neondb for a transitional Neon credential; the exact 20-character PGCF database identity for WSS.
+   */
+  database: string;
+  provider?: "pgcf";
+  transport?: "wss";
+  /**
+   * Verified WSS origin ending in / and matching host. The local bridge adds /v2 and the bound database and user; no public PostgreSQL TCP endpoint.
+   */
+  websocket_url?: string;
+  label: string | null;
+  state: "active" | "expired" | "revoked";
+  issued_at: string;
+  expires_at: string;
+  revoked_at: string | null;
+  revocation_reason: "principal" | "expired" | "budget" | "creation_failed" | "data_change" | null;
+  /**
+   * Returned once as credential material. For PGCF this identifies a WSS transport, never direct public TCP. Never place it in command arguments, files, notes or source.
    */
   connection_uri: string;
   /**
-   * The same credential as a ready psql invocation.
+   * For PGCF, a secret-free ohmyhost database psql invocation that obtains and revokes its own session credential. Transitional Neon responses retain their original direct invocation.
    */
   psql_command: string;
 };
@@ -1102,7 +1146,7 @@ export type Sha256Digest = string;
 export type ProjectDataMode = "shared" | "isolated";
 
 /**
- * Chosen when the project is created and immutable afterwards. us (default) places the project's database, files, build sandbox and build objects in the US; eu places them in the EU. Prices are identical. ohmyhost.yaml storage.jurisdiction must equal this value.
+ * Chosen at project creation and immutable through customer operations. us (default) or eu places new build resources and, when no storage is already assigned, new file buckets. Existing buckets, source repositories and historical artifacts retain their recorded locations independently of a platform-authorized project-region migration. New PGCF application databases follow the selected project region; existing owner-authorized migrations target US1. Read database compute for the actual database region. storage.jurisdiction must match the project's recorded storage location, or this region when no storage custody exists. Project context reports the authoritative storage jurisdiction. Prices are identical in both project regions.
  */
 export type HostingRegion = "us" | "eu";
 
@@ -1362,6 +1406,8 @@ export type ProblemDetails = {
     | "paid_plan_required"
     | "project_budget_exceeded"
     | "compute_performance_paid_required"
+    | "compute_paid_required"
+    | "compute_storage_shrink_requires_migration"
     | "compute_performance_unavailable"
     | "database_write_pending"
     | "database_access_limit"
@@ -1486,20 +1532,40 @@ export type DatabaseCompute = {
   environment: "dev" | "prod";
   data_mode: "shared" | "isolated";
   observed_at: string;
-  database: null | {
-    min_cu: number;
-    max_cu: number;
-    min_memory_gb: number;
-    max_memory_gb: number;
-    /**
-     * Configured timeout: 0 is provider default; -1 disables suspension.
-     */
-    suspend_timeout_seconds: number;
-    state: "init" | "active" | "idle";
-    pending_state: "init" | "active" | "idle" | null;
-    disabled: boolean;
-    region: string;
-  };
+  database:
+    | null
+    | FixedDatabaseCompute
+    | {
+        min_cu: number;
+        max_cu: number;
+        min_memory_gb: number;
+        max_memory_gb: number;
+        /**
+         * Configured timeout: 0 is provider default; -1 disables suspension.
+         */
+        suspend_timeout_seconds: number;
+        state: "init" | "active" | "idle";
+        pending_state: "init" | "active" | "idle" | null;
+        disabled: boolean;
+        region: string;
+      };
+};
+
+/**
+ * Fixed resources; storage includes engine and WAL overhead. First provisioning is distinct from a sleeping database.
+ */
+export type FixedDatabaseCompute = {
+  provider: "pgcf";
+  size_class_id: "r256-s500m" | "r512-s1g" | "r1024-s2g" | "r2048-s4g" | "r4096-s8g";
+  memory_mib: 256 | 512 | 1024 | 2048 | 4096;
+  cpu_millicores: 250 | 500 | 1000 | 2000;
+  storage_mib: 500 | 1024 | 2048 | 4096 | 8192;
+  max_connections: 20 | 40 | 80 | 160 | 200;
+  suspend_timeout_seconds: number;
+  state: "provisioning" | "cold" | "warm" | "suspended" | "error";
+  pending_state: "provisioning" | "cold" | "warm" | "suspended" | "error" | null;
+  disabled: boolean;
+  region: "us" | "eu";
 };
 
 export type ProjectContext = {
@@ -7457,9 +7523,10 @@ export type GetDatabaseComputeResponse =
   GetDatabaseComputeResponses[keyof GetDatabaseComputeResponses];
 
 export type ChangeDatabaseComputeData = {
-  body: {
+  body: unknown & {
     environment: "dev" | "prod";
-    profile: "standard" | "performance";
+    profile?: "standard" | "performance";
+    memory_mib?: 256 | 512 | 1024 | 2048 | 4096;
     confirm: true;
   };
   headers: {

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

@@ -6,5 +6,6 @@ export {
 } from "./generated/client/index.js";
 export * from "./generated/index.js";
 export * from "./managed-mail.js";
+export * from "./managed-mail-attachment.js";
 
 export * from "./shared-mail.js";