supabase 2.98.1 → 2.99.0-beta.1

package/README.md

@@ -1,177 +1,179 @@
-# Supabase CLI
+# supabase
 
-[![Coverage Status](https://coveralls.io/repos/github/supabase/cli/badge.svg?branch=develop)](https://coveralls.io/github/supabase/cli?branch=develop) [![Bitbucket Pipelines](https://img.shields.io/bitbucket/pipelines/supabase-cli/setup-cli/master?style=flat-square&label=Bitbucket%20Canary)](https://bitbucket.org/supabase-cli/setup-cli/pipelines) [![Gitlab Pipeline Status](https://img.shields.io/gitlab/pipeline-status/sweatybridge%2Fsetup-cli?label=Gitlab%20Canary)
-](https://gitlab.com/sweatybridge/setup-cli/-/pipelines)
+The TypeScript/Bun Supabase CLI in this repo.
 
-[Supabase](https://supabase.io) is an open source Firebase alternative. We're building the features of Firebase using enterprise-grade open source tools.
+This workspace contains:
 
-This repository contains all the functionality for Supabase CLI.
+- the published `supabase` package
+- the `supabase` binary entrypoint
+- local-development commands backed by `@supabase/stack`
+- login and machine-readable output support
 
-- [x] Running Supabase locally
-- [x] Managing database migrations
-- [x] Creating and deploying Supabase Functions
-- [x] Generating types directly from your database schema
-- [x] Making authenticated HTTP requests to [Management API](https://supabase.com/docs/reference/api/introduction)
+## Status
 
-## Getting started
+This workspace currently contains the next/V3 CLI shell and the scaffolding for a legacy shell.
 
-### Install the CLI
+For current migration/parity status, see:
 
-Available via [NPM](https://www.npmjs.com) as dev dependency. To install:
+- [`docs/go-cli-porting-status.md`](/Users/jgoux/Code/supabase/dx-labs/apps/cli/docs/go-cli-porting-status.md)
 
-```bash
-npm i supabase --save-dev
-```
+For the generated command/reference docs, see:
 
-When installing with yarn 4, you need to disable experimental fetch with the following nodejs config.
+- [`docs/go-cli-reference.md`](/Users/jgoux/Code/supabase/dx-labs/apps/cli/docs/go-cli-reference.md)
+- [`docs/supabase-home.md`](/Users/jgoux/Code/supabase/dx-labs/apps/cli/docs/supabase-home.md)
+- [`../../packages/stack/docs/service-versioning.md`](/Users/jgoux/Code/supabase/dx-labs/packages/stack/docs/service-versioning.md)
 
-```
-NODE_OPTIONS=--no-experimental-fetch yarn add supabase
-```
+The README is intentionally brief. Command details should live in the generated docs and the parity tracker above.
 
-> **Note**
-For Bun versions below v1.0.17, you must add `supabase` as a [trusted dependency](https://bun.sh/guides/install/trusted) before running `bun add -D supabase`.
+## Run From Source
 
-<details>
-  <summary><b>macOS</b></summary>
+From the workspace:
 
-  Available via [Homebrew](https://brew.sh). To install:
+```sh
+cd apps/cli
+pnpm dev:next -- --help
+```
 
-  ```sh
-  brew install supabase/tap/supabase
-  ```
+Examples:
 
-  To install the beta release channel:
-  
-  ```sh
-  brew install supabase/tap/supabase-beta
-  brew link --overwrite supabase-beta
-  ```
-  
-  To upgrade:
+```sh
+pnpm dev:next -- start
+pnpm dev:next -- start --mode docker
+pnpm dev:next -- start --detach
+pnpm dev:next -- status
+pnpm dev:next -- logs
+pnpm dev:next -- login --no-browser
+pnpm dev:legacy -- hello
+```
 
-  ```sh
-  brew upgrade supabase
-  ```
-</details>
+### Legacy shell and the Go binary
 
-<details>
-  <summary><b>Windows</b></summary>
+Phase 0 commands in the legacy shell proxy to the Go CLI binary. To run these commands from source you need `supabase` (the Go CLI) available on your PATH.
 
-  Available via [Scoop](https://scoop.sh). To install:
+For convenience, create a shell alias instead of using `pnpm dev:legacy` directly. For example in `.zshrc`:
 
-  ```powershell
-  scoop bucket add supabase https://github.com/supabase/scoop-bucket.git
-  scoop install supabase
-  ```
+```sh
+alias supabase-dev="bun /absolute/path/to/dx-lab/apps/cli/src/legacy/main.ts"
+```
 
-  To upgrade:
+Then Phase 0 commands resolve the Go binary via PATH automatically:
 
-  ```powershell
-  scoop update supabase
-  ```
-</details>
+```sh
+supabase-dev orgs list   # proxied to supabase on PATH
+supabase-dev login       # native TypeScript
+```
 
-<details>
-  <summary><b>Linux</b></summary>
+You can also point `SUPABASE_GO_BINARY` at a specific binary to skip the PATH lookup:
 
-  Available via [Homebrew](https://brew.sh) and Linux packages.
+```sh
+export SUPABASE_GO_BINARY=/path/to/supabase
+```
 
-  #### via Homebrew
+## Build
 
-  To install:
+There are two separate build paths depending on what you need.
 
-  ```sh
-  brew install supabase/tap/supabase
-  ```
+### Source bundles (development)
 
-  To upgrade:
+From `apps/cli`:
 
-  ```sh
-  brew upgrade supabase
-  ```
+```sh
+pnpm build
+pnpm build:next
+pnpm build:legacy
+pnpm build:shim
+```
 
-  #### via Linux packages
+Output in `dist/`:
 
-  Linux packages are provided in [Releases](https://github.com/supabase/cli/releases). To install, download the `.apk`/`.deb`/`.rpm`/`.pkg.tar.zst` file depending on your package manager and run the respective commands.
+- `dist/supabase.js` — base shim that routes to the correct platform binary
+- `dist/main-next.js` — next shell bundle
+- `dist/main-legacy.js` — legacy shell bundle
 
-  ```sh
-  sudo apk add --allow-untrusted <...>.apk
-  ```
+### Platform releases (Bun single-file executables)
 
-  ```sh
-  sudo dpkg -i <...>.deb
-  ```
+Used at release time to produce the compiled binaries that go into the platform-specific npm packages:
 
-  ```sh
-  sudo rpm -i <...>.rpm
-  ```
+```sh
+# next shell (TS only)
+bun scripts/build.ts --shell next --version X.Y.Z
 
-  ```sh
-  sudo pacman -U <...>.pkg.tar.zst
-  ```
-</details>
+# legacy shell (TS SFE + Go binary for each platform)
+bun scripts/build.ts --shell legacy --version X.Y.Z
+```
 
-<details>
-  <summary><b>Other Platforms</b></summary>
+For the legacy shell, this also cross-compiles the Go CLI binary from `apps/cli-go/` and places both binaries in `packages/cli-{platform}/bin/`.
 
-  You can also install the CLI via [go modules](https://go.dev/ref/mod#go-install) without the help of package managers.
+See [`docs/binary-distribution.md`](./docs/binary-distribution.md) for a full explanation of the packaging model.
 
-  ```sh
-  go install github.com/supabase/cli@latest
-  ```
+## Architecture
 
-  Add a symlink to the binary in `$PATH` for easier access:
+The CLI is built on `effect/unstable/cli`.
 
-  ```sh
-  ln -s "$(go env GOPATH)/bin/cli" /usr/bin/supabase
-  ```
+Important areas:
 
-  This works on other non-standard Linux distros.
-</details>
+- `src/shared/cli/` for shared runner logic, roots, and global flags
+- `src/next/commands/` for the next/V3 command tree
+- `src/legacy/commands/` for the legacy command tree
+- `src/shared/output/` for text / JSON / NDJSON output policies
+- `src/shared/runtime/` for TTY, stdin, browser, Ink, and process-control services
+- `src/next/auth/` for login-related services
 
-<details>
-  <summary><b>Community Maintained Packages</b></summary>
+The local stack commands use `@supabase/stack` for lifecycle, daemon transport, status, and logs.
+That stack layer now has an explicit preparation phase, so foreground and detached `start` flows
+can surface `Downloading` before normal runtime states.
 
-  Available via [pkgx](https://pkgx.sh/). Package script [here](https://github.com/pkgxdev/pantry/blob/main/projects/supabase.com/cli/package.yml).
-  To install in your working directory:
+Useful companion docs:
 
-  ```bash
-  pkgx install supabase
-  ```
+- [`../../packages/stack/docs/architecture.md`](/Users/jgoux/Code/supabase/dx-labs/packages/stack/docs/architecture.md)
+- [`../../packages/stack/docs/detach-mode.md`](/Users/jgoux/Code/supabase/dx-labs/packages/stack/docs/detach-mode.md)
+- [`docs/ui.md`](/Users/jgoux/Code/supabase/dx-labs/apps/cli/docs/ui.md)
 
-  Available via [Nixpkgs](https://nixos.org/). Package script [here](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/tools/supabase-cli/default.nix).
-</details>
+## Development
 
-### Run the CLI
+From `apps/cli`:
 
-```bash
-supabase bootstrap
+```sh
+pnpm check:all
+pnpm fix:all
+pnpm test
 ```
 
-Or using npx:
+Useful subsets:
 
-```bash
-npx supabase bootstrap
+```sh
+pnpm test:core                 # unit + integration (no binary required)
+pnpm test:legacy-integration   # legacy behavioral tests (requires SUPABASE_GO_BINARY — see CLAUDE.md)
+pnpm test:e2e                  # end-to-end subprocess tests
 ```
 
-The bootstrap command will guide you through the process of setting up a Supabase project using one of the [starter](https://github.com/supabase-community/supabase-samples/blob/main/samples.json) templates.
+## Publishing
 
-## Docs
+This workspace publishes the main `supabase` package.
 
-Command & config reference can be found [here](https://supabase.com/docs/reference/cli/about).
+Release channels are split by npm dist-tag:
 
-## Breaking changes
+- stable publishes the legacy shell to `latest`
+- alpha publishes the next/V3 shell to `alpha`
 
-We follow semantic versioning for changes that directly impact CLI commands, flags, and configurations.
+The release automation is split across:
 
-However, due to dependencies on other service images, we cannot guarantee that schema migrations, seed.sql, and generated types will always work for the same CLI major version. If you need such guarantees, we encourage you to pin a specific version of CLI in package.json.
+- [`.github/workflows/release-stable.yml`](../../.github/workflows/release-stable.yml)
+- [`.github/workflows/release-alpha.yml`](../../.github/workflows/release-alpha.yml)
 
-## Developing
+### Platform packages
 
-To run from source:
+Platform-specific packages live under:
 
-```sh
-# Go >= 1.22
-go run . help
-```
+- `packages/cli-darwin-*`
+- `packages/cli-linux-*`
+- `packages/cli-windows-*`
+
+Each platform package ships two binaries for the legacy stable channel:
+
+- `bin/supabase` — the compiled TypeScript SFE (Bun single-file executable)
+- `bin/supabase-go` — the compiled Go CLI binary, used by Phase 0 proxy commands
+
+The Go binary is compiled from `apps/cli-go/` at release time. Run `pnpm repos:install` after a fresh clone to make that source available.
+
+See [`docs/binary-distribution.md`](./docs/binary-distribution.md) for the full packaging model.

package/dist/supabase.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+// src/shared/cli/bin.ts
+import { execFileSync } from "node:child_process";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+var PLATFORMS = {
+  darwin: { arm64: ["darwin-arm64"], x64: ["darwin-x64"] },
+  linux: {
+    arm64: ["linux-arm64", "linux-arm64-musl"],
+    x64: ["linux-x64", "linux-x64-musl"]
+  },
+  win32: { arm64: ["windows-arm64"], x64: ["windows-x64"] }
+};
+var platformMap = PLATFORMS[process.platform];
+if (!platformMap)
+  throw new Error(`Unsupported platform: ${process.platform}`);
+var candidates = platformMap[os.arch()];
+if (!candidates)
+  throw new Error(`Unsupported architecture: ${os.arch()} on ${process.platform}`);
+var ext = process.platform === "win32" ? ".exe" : "";
+var require2 = createRequire(import.meta.url);
+var binPath;
+for (const suffix of candidates) {
+  try {
+    const pkgPath = path.dirname(require2.resolve(`@supabase/cli-${suffix}/package.json`));
+    binPath = path.join(pkgPath, "bin", `supabase${ext}`);
+    break;
+  } catch {}
+}
+if (!binPath) {
+  throw new Error(`No matching Supabase CLI binary package found for ${process.platform}-${os.arch()}`);
+}
+try {
+  execFileSync(binPath, process.argv.slice(2), { stdio: "inherit" });
+} catch (e) {
+  if (e && typeof e === "object" && "status" in e && typeof e.status === "number")
+    process.exit(e.status);
+  throw e;
+}

package/package.json

@@ -1,45 +1,133 @@
 {
   "name": "supabase",
-  "version": "2.98.1",
+  "version": "2.99.0-beta.1",
+  "private": false,
   "description": "Supabase CLI",
-  "repository": "supabase/cli",
-  "homepage": "https://supabase.com/docs/reference/cli",
-  "bugs": "https://github.com/supabase/cli/issues",
+  "homepage": "https://github.com/supabase/cli#readme",
+  "bugs": {
+    "url": "https://github.com/supabase/cli/issues"
+  },
   "license": "MIT",
-  "author": "Supabase",
-  "type": "module",
-  "engines": {
-    "npm": ">=8"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/supabase/cli.git",
+    "directory": "apps/cli"
+  },
+  "bin": {
+    "supabase": "dist/supabase.js"
   },
   "files": [
-    "scripts"
+    "dist/supabase.js"
   ],
-  "scripts": {
-    "postinstall": "node scripts/postinstall.js"
-  },
-  "bin": {
-    "supabase": "bin/supabase"
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "bin-links": "^6.0.0",
-    "https-proxy-agent": "^9.0.0",
-    "node-fetch": "^3.3.2",
-    "tar": "7.5.13"
+    "@clack/prompts": "^1.2.0",
+    "@effect/atom-react": "4.0.0-beta.54",
+    "@effect/platform-bun": "^4.0.0-beta.43",
+    "@napi-rs/keyring": "^1.1.2",
+    "@vercel/detect-agent": "^1.2.3",
+    "effect": "^4.0.0-beta.43",
+    "ink": "^7.0.1",
+    "ink-spinner": "^5.0.0",
+    "posthog-node": "^5.29.4",
+    "react": "^19.2.5"
+  },
+  "devDependencies": {
+    "@effect/vitest": "^4.0.0-beta.43",
+    "@tsconfig/bun": "^1.0.10",
+    "@types/bun": "^1.3.12",
+    "@types/react": "^19.2.14",
+    "@typescript/native-preview": "7.0.0-dev.20260422.1",
+    "@vitest/coverage-istanbul": "^4.1.5",
+    "knip": "^6.6.1",
+    "oxfmt": "^0.46.0",
+    "oxlint": "^1.61.0",
+    "oxlint-tsgolint": "^0.21.1",
+    "react-devtools-core": "^7.0.1",
+    "vitest": "^4.1.5",
+    "@supabase/api": "0.1.0",
+    "@supabase/config": "0.1.0",
+    "@supabase/stack": "0.1.0"
+  },
+  "optionalDependencies": {
+    "@supabase/cli-darwin-arm64": "2.99.0-beta.1",
+    "@supabase/cli-darwin-x64": "2.99.0-beta.1",
+    "@supabase/cli-linux-arm64": "2.99.0-beta.1",
+    "@supabase/cli-linux-x64-musl": "2.99.0-beta.1",
+    "@supabase/cli-linux-x64": "2.99.0-beta.1",
+    "@supabase/cli-linux-arm64-musl": "2.99.0-beta.1",
+    "@supabase/cli-windows-arm64": "2.99.0-beta.1",
+    "@supabase/cli-windows-x64": "2.99.0-beta.1"
   },
   "release": {
     "branches": [
-      {
-        "name": "+([0-9])?(.{+([0-9]),x}).x",
-        "channel": "hotfix"
-      },
+      "main",
       {
         "name": "develop",
-        "channel": "latest"
+        "prerelease": "beta"
       }
     ],
     "plugins": [
-      "@semantic-release/commit-analyzer",
-      "@semantic-release/git"
+      "@semantic-release/commit-analyzer"
     ]
+  },
+  "knip": {
+    "entry": [
+      "src/shared/cli/bin.ts",
+      "src/**/*.test.ts",
+      "src/**/*.e2e.test.ts"
+    ],
+    "ignore": [
+      "scripts/*.ts",
+      "tests/**/*.ts"
+    ],
+    "ignoreBinaries": [
+      "nx"
+    ],
+    "ignoreDependencies": [
+      "@typescript/native-preview",
+      "oxfmt",
+      "oxlint",
+      "oxlint-tsgolint"
+    ]
+  },
+  "nx": {
+    "targets": {
+      "build": {
+        "outputs": [
+          "{projectRoot}/dist"
+        ],
+        "dependsOn": [
+          {
+            "projects": [
+              "cli-go"
+            ],
+            "target": "build"
+          }
+        ]
+      },
+      "test:smoke": {
+        "cache": false
+      }
+    },
+    "implicitDependencies": [
+      "cli-go"
+    ]
+  },
+  "scripts": {
+    "build": "pnpm build:next && pnpm build:legacy && pnpm build:shim",
+    "build:next": "bun build src/next/main.ts --outfile dist/main-next.js --target bun --packages external",
+    "build:legacy": "bun build src/legacy/main.ts --outfile dist/main-legacy.js --target bun --packages external",
+    "build:shim": "bun build src/shared/cli/bin.ts --outfile dist/supabase.js --target node",
+    "dev:next": "pnpm exec bun src/next/main.ts",
+    "dev:legacy": "pnpm exec bun src/legacy/main.ts",
+    "test": "nx run-many -t test:core test:e2e --projects=$npm_package_name",
+    "test:core": "nx run-many -t test:unit test:integration --projects=$npm_package_name --coverage.enabled",
+    "test:smoke": "bun run tests/smoke-test.ts",
+    "check:all": "nx run-many -t types:check lint:check fmt:check knip:check --projects=$npm_package_name",
+    "fix:all": "nx run-many -t lint:fix fmt:fix knip:fix --projects=$npm_package_name"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 Supabase, Inc. and contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/scripts/postinstall.js

@@ -1,180 +0,0 @@
-#!/usr/bin/env node
-
-// Ref 1: https://github.com/sanathkr/go-npm
-// Ref 2: https://medium.com/xendit-engineering/how-we-repurposed-npm-to-publish-and-distribute-our-go-binaries-for-internal-cli-23981b80911b
-"use strict";
-
-import binLinks from "bin-links";
-import { createHash } from "crypto";
-import fs from "fs";
-import fetch from "node-fetch";
-import { Agent } from "https";
-import { HttpsProxyAgent } from "https-proxy-agent";
-import path from "path";
-import { extract } from "tar";
-import zlib from "zlib";
-
-// Mapping from Node's `process.arch` to Golang's `$GOARCH`
-const ARCH_MAPPING = {
-  x64: "amd64",
-  arm64: "arm64",
-};
-
-// Mapping between Node's `process.platform` to Golang's
-const PLATFORM_MAPPING = {
-  darwin: "darwin",
-  linux: "linux",
-  win32: "windows",
-};
-
-const arch = ARCH_MAPPING[process.arch];
-const platform = PLATFORM_MAPPING[process.platform];
-
-// TODO: import pkg from "../package.json" assert { type: "json" };
-const readPackageJson = async () => {
-  const contents = await fs.promises.readFile("package.json");
-  return JSON.parse(contents);
-};
-
-// Build the download url from package.json
-const getDownloadUrl = (packageJson) => {
-  const pkgName = packageJson.name;
-  const version = packageJson.version;
-  const repo = packageJson.repository;
-  const url = `https://github.com/${repo}/releases/download/v${version}/${pkgName}_${platform}_${arch}.tar.gz`;
-  return url;
-};
-
-const fetchAndParseCheckSumFile = async (packageJson, agent) => {
-  const version = packageJson.version;
-  const pkgName = packageJson.name;
-  const repo = packageJson.repository;
-  const checksumFileUrl = `https://github.com/${repo}/releases/download/v${version}/${pkgName}_${version}_checksums.txt`;
-
-  // Fetch the checksum file
-  console.info("Downloading", checksumFileUrl);
-  const response = await fetch(checksumFileUrl, { agent });
-  if (response.ok) {
-    const checkSumContent = await response.text();
-    const lines = checkSumContent.split("\n");
-
-    const checksums = {};
-    for (const line of lines) {
-      const [checksum, packageName] = line.split(/\s+/);
-      checksums[packageName] = checksum;
-    }
-
-    return checksums;
-  } else {
-    console.error(
-      "Could not fetch checksum file",
-      response.status,
-      response.statusText
-    );
-  }
-};
-
-const errGlobal = `Installing Supabase CLI as a global module is not supported.
-Please use one of the supported package managers: https://github.com/supabase/cli#install-the-cli
-`;
-const errChecksum = "Checksum mismatch. Downloaded data might be corrupted.";
-const errUnsupported = `Installation is not supported for ${process.platform} ${process.arch}`;
-
-/**
- * Reads the configuration from application's package.json,
- * downloads the binary from package url and stores at
- * ./bin in the package's root.
- *
- *  See: https://docs.npmjs.com/files/package.json#bin
- */
-async function main() {
-  const yarnGlobal = JSON.parse(
-    process.env.npm_config_argv || "{}"
-  ).original?.includes("global");
-  if (process.env.npm_config_global || yarnGlobal) {
-    throw errGlobal;
-  }
-  if (!arch || !platform) {
-    throw errUnsupported;
-  }
-
-  // Read from package.json and prepare for the installation.
-  const pkg = await readPackageJson();
-  if (platform === "windows") {
-    // Update bin path in package.json
-    pkg.bin[pkg.name] += ".exe";
-  }
-
-  // Prepare the installation path by creating the directory if it doesn't exist.
-  const binPath = pkg.bin[pkg.name];
-  const binDir = path.dirname(binPath);
-  await fs.promises.mkdir(binDir, { recursive: true });
-
-  // Create the agent that will be used for all the fetch requests later.
-  const proxyUrl =
-    process.env.npm_config_https_proxy ||
-    process.env.npm_config_http_proxy ||
-    process.env.npm_config_proxy;
-  // Keeps the TCP connection alive when sending multiple requests
-  // Ref: https://github.com/node-fetch/node-fetch/issues/1735
-  const agent = proxyUrl
-    ? new HttpsProxyAgent(proxyUrl, { keepAlive: true })
-    : new Agent({ keepAlive: true });
-
-  // First, fetch the checksum map.
-  const checksumMap = await fetchAndParseCheckSumFile(pkg, agent);
-
-  // Then, download the binary.
-  const url = getDownloadUrl(pkg);
-  console.info("Downloading", url);
-  const resp = await fetch(url, { agent });
-  const hash = createHash("sha256");
-  const pkgNameWithPlatform = `${pkg.name}_${platform}_${arch}.tar.gz`;
-
-  // Then, decompress the binary -- we will first Un-GZip, then we will untar.
-  const ungz = zlib.createGunzip();
-  const binName = path.basename(binPath);
-  const untar = extract({ cwd: binDir }, [binName]);
-
-  // Update the hash with the binary data as it's being downloaded.
-  resp.body
-    .on("data", (chunk) => {
-      hash.update(chunk);
-    })
-    // Pipe the data to the ungz stream.
-    .pipe(ungz);
-
-  // After the ungz stream has ended, verify the checksum.
-  ungz
-    .on("end", () => {
-      const expectedChecksum = checksumMap?.[pkgNameWithPlatform];
-      // Skip verification if we can't find the file checksum
-      if (!expectedChecksum) {
-        console.warn("Skipping checksum verification");
-        return;
-      }
-      const calculatedChecksum = hash.digest("hex");
-      if (calculatedChecksum !== expectedChecksum) {
-        throw errChecksum;
-      }
-      console.info("Checksum verified.");
-    })
-    // Pipe the data to the untar stream.
-    .pipe(untar);
-
-  // Wait for the untar stream to finish.
-  await new Promise((resolve, reject) => {
-    untar.on("error", reject);
-    untar.on("end", () => resolve());
-  });
-
-  // Link the binaries in postinstall to support yarn
-  await binLinks({
-    path: path.resolve("."),
-    pkg: { ...pkg, bin: { [pkg.name]: binPath } },
-  });
-
-  console.info("Installed Supabase CLI successfully");
-}
-
-await main();