sqlsift-lsp 0.1.0

package/.gitignore

@@ -0,0 +1,2 @@
+/node_modules
+

package/CHANGELOG.md

@@ -0,0 +1,157 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0-alpha.8] - 2026-02-13
+
+### Changed
+- **Project renamed from sqlsurge to sqlsift** to avoid name conflict with existing [senkenn/sqlsurge](https://github.com/senkenn/sqlsurge) VS Code extension
+  - crate names: `sqlsift-core`, `sqlsift-cli`, `sqlsift-lsp`
+  - npm package: `sqlsift-cli`
+  - binary: `sqlsift`
+  - config file: `sqlsift.toml`
+
+### Fixed
+- Fix `auto-tag.yml` release automation: add `actions: write` permission to enable `gh workflow run`
+
+## [0.1.0-alpha.7] - 2026-02-11
+
+### Added
+- **LSP server** (`sqlsift-lsp`): Language Server Protocol support for real-time SQL diagnostics in editors
+  - textDocument/didOpen, didChange, didSave, didClose
+  - Automatic schema loading from `sqlsift.toml`
+  - Schema file change detection with catalog rebuild
+  - Diagnostic severity, error codes, and help messages
+  - 12 unit tests (diagnostic conversion, state management)
+- **VS Code extension** (`editors/vscode/`): Thin LSP client for VS Code
+  - Configurable server path via `sqlsift.serverPath` setting
+  - SQL language configuration (comments, brackets)
+- **Neovim support**: Works out of the box with built-in LSP client
+
+### Fixed
+- `SELECT *` diagnostic now points to the `SELECT` keyword instead of file start
+
+## [0.1.0-alpha.6] - 2026-02-08
+
+### Added
+- **Type inference engine**: SQL expression type checking for WHERE clauses and JOIN conditions
+  - E0003 (type-mismatch): Detect incompatible type comparisons (e.g., `WHERE id = 'text'`)
+  - E0007 (join-type-mismatch): Detect JOIN condition type incompatibilities (e.g., `ON users.id = orders.name`)
+  - Binary operator type validation: comparisons (=, !=, <, >, <=, >=) and arithmetic (+, -, *, /)
+  - Nested expression type inference: `(a + b) * 2 = c`
+  - Numeric type compatibility: implicit casts between TINYINT, SMALLINT, INTEGER, BIGINT
+
+### Changed
+- Reorganized test suite: moved integration tests to `tests/analyzer_tests.rs` (74 tests)
+- Improved API documentation with doc-test examples
+- Replaced `unwrap()` with `expect()` in catalog code for better error messages
+
+## [0.1.0-alpha.5] - 2026-02-08
+
+### Added
+- **MySQL dialect support**: Full schema parsing and query validation for MySQL
+- MySQL-specific types: `TINYINT`, `MEDIUMINT`, `UNSIGNED` integer variants, `DATETIME`, inline `ENUM`
+- `AUTO_INCREMENT` handling with implicit NOT NULL inference
+- 10 MySQL unit tests covering schema parsing, SELECT, JOIN, INSERT, UPDATE, DELETE, subquery, CTE, and error detection
+- Real-world MySQL test fixtures:
+  - **Sakila** (BSD): 16 tables, 40 valid queries, 12 error detection tests
+  - **Chinook MySQL** (MIT): 11 tables, 40 valid queries, 12 error detection tests
+
+## [0.1.0-alpha.4] - 2026-02-08
+
+### Added
+- **Derived table (subquery in FROM) support**: Resolve aliases and validate column references for `FROM (SELECT ...) AS sub`
+- **LATERAL vs non-LATERAL scope isolation**: Non-LATERAL subqueries correctly cannot see outer FROM tables
+- **UPDATE ... FROM / DELETE ... USING**: PostgreSQL-specific multi-table update/delete syntax
+- **Recursive CTE support**: CTEs can reference themselves in recursive queries
+- **Table-valued functions in FROM**: `generate_series()`, `unnest()` etc. recognized as table sources
+- **UNION/INTERSECT/EXCEPT column inference**: Infer output columns from set operations for CTE/derived table validation
+- **Comprehensive expression resolution**: AtTimeZone, Collate, Ceil/Floor, Overlay, IsDistinctFrom, IsUnknown, SimilarTo, Tuple, Array, Subscript, Method, GroupingSets/Cube/Rollup
+- **Function FILTER/OVER clause resolution**: Validate column references in `COUNT(*) FILTER (WHERE ...)` and `OVER (PARTITION BY ... ORDER BY ...)`
+- **ORDER BY column resolution**: Validate ORDER BY references including SELECT alias support
+- **Named function argument resolution**: Handle `func(name => value)` syntax
+- 72 PostgreSQL pattern test fixtures (basic, advanced, and expression coverage)
+
+### Fixed
+- WHERE subquery scope leak: subqueries in IN/EXISTS no longer pollute outer table scope
+- VALUES derived table column aliases now correctly applied
+- Empty derived_columns (table-valued functions) no longer cause false column-not-found errors
+
+## [0.1.0-alpha.3] - 2026-02-08
+
+### Added
+- **`--dialect` flag wired up**: CLI `--dialect` option now correctly configures the SQL parser dialect (previously ignored)
+- **Real-world schema test fixtures**: Chinook, Pagila, Northwind schemas with comprehensive valid/invalid query tests covering SELECT, JOIN, INSERT, UPDATE, DELETE, subqueries, and CTEs
+- Third-party license file for test fixtures
+
+### Fixed
+- `--dialect` CLI flag was completely ignored; PostgreSQL dialect was hardcoded throughout
+- ALTER TABLE warnings for non-schema-affecting operations (e.g., `OWNER TO`) are now suppressed
+
+## [0.1.0-alpha.2] - 2026-02-08
+
+### Added
+- **CHECK constraints**: Column-level and table-level CHECK constraint parsing and storage
+- **CREATE TYPE AS ENUM**: Enum type definitions with value storage in catalog
+- **GENERATED AS IDENTITY**: ALWAYS and BY DEFAULT identity columns with implicit NOT NULL
+- **CREATE VIEW**: View definitions with column inference from SELECT projection, wildcard expansion, and query-time resolution
+- **ALTER TABLE**: ADD COLUMN, DROP COLUMN, RENAME COLUMN, RENAME TABLE, ADD CONSTRAINT support
+- **Resilient SQL parsing**: Gracefully skip unsupported DDL statements (CREATE FUNCTION, CREATE TRIGGER, CREATE DOMAIN, etc.) instead of failing the entire schema file
+- Real-world test fixtures from Sakila and webknossos schemas
+
+### Fixed
+- Schema files with mixed supported/unsupported SQL statements now parse correctly
+- Comments preceding DDL statements no longer cause statement-by-statement parsing to skip valid statements
+
+### Changed
+- Known Limitations updated: VIEWs are now supported; ALTER TABLE is now supported
+
+## [0.1.0-alpha.1] - 2026-02-07
+
+### Added
+- Initial release of sqlsift
+- SQL static analysis against schema definitions
+- Support for PostgreSQL dialect
+- Schema parsing from CREATE TABLE statements
+- Query validation for SELECT, INSERT, UPDATE, DELETE statements
+- Error detection:
+  - E0001: Table not found
+  - E0002: Column not found
+  - E0003: Type mismatch (reserved)
+  - E0004: Potential NULL violation (reserved)
+  - E0005: Column count mismatch in INSERT
+  - E0006: Ambiguous column reference
+  - E0007: JOIN type mismatch (reserved)
+  - E1000: Parse error
+- JOIN condition validation
+- Subquery support (including correlated subqueries)
+- CTE (Common Table Expressions) support
+- Error position reporting (line and column numbers)
+- Multiple output formats: human-readable, JSON, SARIF
+- Configuration file support (sqlsift.toml)
+- Rule disabling via CLI (--disable) or config file
+- CLI with check, schema, and parse commands
+- Typo suggestions using Levenshtein distance
+- CI/CD integration support via exit codes and SARIF output
+- Framework integration examples (Rails, Prisma)
+
+### Known Limitations
+- Only PostgreSQL dialect fully supported
+- Type checking is basic (existence only, not full type inference)
+- No support for VIEWs, functions, or stored procedures
+- Derived table (subquery in FROM) column resolution is incomplete
+
+[Unreleased]: https://github.com/yukikotani231/sqlsift/compare/v0.1.0-alpha.8...HEAD
+[0.1.0-alpha.8]: https://github.com/yukikotani231/sqlsift/compare/v0.1.0-alpha.7...v0.1.0-alpha.8
+[0.1.0-alpha.7]: https://github.com/yukikotani231/sqlsift/compare/v0.1.0-alpha.6...v0.1.0-alpha.7
+[0.1.0-alpha.6]: https://github.com/yukikotani231/sqlsift/compare/v0.1.0-alpha.5...v0.1.0-alpha.6
+[0.1.0-alpha.5]: https://github.com/yukikotani231/sqlsift/compare/v0.1.0-alpha.4...v0.1.0-alpha.5
+[0.1.0-alpha.4]: https://github.com/yukikotani231/sqlsift/compare/v0.1.0-alpha.3...v0.1.0-alpha.4
+[0.1.0-alpha.3]: https://github.com/yukikotani231/sqlsift/compare/v0.1.0-alpha.2...v0.1.0-alpha.3
+[0.1.0-alpha.2]: https://github.com/yukikotani231/sqlsift/compare/v0.1.0-alpha.1...v0.1.0-alpha.2
+[0.1.0-alpha.1]: https://github.com/yukikotani231/sqlsift/releases/tag/v0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 yukikotani
+
+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/README.md

@@ -0,0 +1,263 @@
+# sqlsift
+
+[![CI](https://github.com/yukikotani231/sqlsift/actions/workflows/ci.yml/badge.svg)](https://github.com/yukikotani231/sqlsift/actions/workflows/ci.yml)
+[![Crates.io](https://img.shields.io/crates/v/sqlsift-cli.svg)](https://crates.io/crates/sqlsift-cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+**SQL static analyzer that validates queries against schema definitions — no database connection required.**
+
+sqlsift parses your DDL files (CREATE TABLE, CREATE VIEW, CREATE TYPE, ALTER TABLE, etc.) and validates SQL queries at build time, catching errors like missing tables, unknown columns, and typos before they reach production.
+
+> **Note:** sqlsift is in early development (alpha). APIs and diagnostics may change between versions. Feedback and contributions are welcome!
+
+## Features
+
+- **Zero database dependency** — Works entirely offline using schema SQL files
+- **Framework agnostic** — Works with Rails, Prisma, raw SQL migrations, and more
+- **Helpful diagnostics** — Clear error messages with suggestions for typos
+- **CI-ready** — JSON and SARIF output formats for integration with CI/CD pipelines
+- **Fast** — Built in Rust for speed
+
+## Installation
+
+### via npm (Recommended)
+
+```bash
+npm install -g sqlsift-cli
+```
+
+Or use directly with `npx`:
+
+```bash
+npx sqlsift-cli check --schema schema.sql query.sql
+```
+
+### via Cargo
+
+```bash
+cargo install sqlsift-cli
+```
+
+### From GitHub Releases
+
+Download the latest binary from [Releases](https://github.com/yukikotani231/sqlsift/releases).
+
+## Quick Start
+
+```bash
+# Validate queries against a schema file
+sqlsift check --schema schema.sql queries/*.sql
+
+# Use multiple schema files
+sqlsift check -s users.sql -s orders.sql queries/*.sql
+
+# Use a migrations directory
+sqlsift check --schema-dir ./migrations queries/*.sql
+```
+
+## Example
+
+Given a schema:
+
+```sql
+-- schema.sql
+CREATE TABLE users (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(100) NOT NULL,
+    email TEXT UNIQUE
+);
+```
+
+And a query with errors:
+
+```sql
+-- query.sql
+SELECT naem, user_id FROM users;
+```
+
+sqlsift will report:
+
+```
+error[E0002]: Column 'naem' not found
+   = help: Did you mean 'name'?
+
+error[E0002]: Column 'user_id' not found
+```
+
+## Framework Integration
+
+### Prisma
+
+Prisma generates SQL migration files automatically:
+
+```bash
+sqlsift check --schema-dir prisma/migrations queries/*.sql
+```
+
+### Rails
+
+With `config.active_record.schema_format = :sql`:
+
+```bash
+sqlsift check --schema db/structure.sql queries/*.sql
+```
+
+Or with SQL migrations:
+
+```bash
+sqlsift check --schema-dir db/migrate queries/*.sql
+```
+
+### Raw SQL
+
+Just point to your schema files:
+
+```bash
+sqlsift check --schema schema/*.sql queries/**/*.sql
+```
+
+## Diagnostic Rules
+
+| Code | Name | Description | Status |
+|------|------|-------------|--------|
+| E0001 | table-not-found | Referenced table does not exist in schema | ✅ Implemented |
+| E0002 | column-not-found | Referenced column does not exist in table | ✅ Implemented |
+| E0003 | type-mismatch | Type incompatibility in expressions (comparisons, arithmetic) | ✅ Implemented |
+| E0004 | potential-null-violation | Possible NOT NULL constraint violation | 🚧 Reserved |
+| E0005 | column-count-mismatch | INSERT column count doesn't match values | ✅ Implemented |
+| E0006 | ambiguous-column | Column reference is ambiguous across tables | ✅ Implemented |
+| E0007 | join-type-mismatch | JOIN condition compares incompatible types | ✅ Implemented |
+
+### Type Inference Coverage (E0003, E0007)
+
+**Currently Detected:**
+- ✅ WHERE clause comparisons (`WHERE id = 'text'`)
+- ✅ Arithmetic operations (`SELECT name + 10`)
+- ✅ JOIN conditions (`ON users.id = orders.user_name`)
+- ✅ INSERT value type mismatches (`INSERT INTO users (id) VALUES ('text')`)
+- ✅ UPDATE assignment type mismatches (`UPDATE users SET id = 'text'`)
+- ✅ Nested expressions (`WHERE (a + b) * 2 = 'text'`)
+- ✅ All comparison operators (=, !=, <, >, <=, >=)
+- ✅ Numeric type compatibility (INTEGER, BIGINT, DECIMAL, etc.)
+
+**Not Yet Detected:**
+- ⏳ CAST expression type inference
+- ⏳ Function return types (COUNT, SUM, AVG, etc.)
+- ⏳ CASE expression type consistency
+- ⏳ Subquery/CTE column type inference
+
+## CLI Reference
+
+```
+sqlsift check [OPTIONS] <FILES>...
+
+Arguments:
+  <FILES>...                SQL files to validate (supports glob patterns)
+
+Options:
+  -s, --schema <FILE>       Schema definition file (can be specified multiple times)
+      --schema-dir <DIR>    Directory containing schema files
+  -c, --config <FILE>       Path to configuration file [default: sqlsift.toml]
+      --disable <RULE>      Disable specific rules (e.g., E0001, E0002)
+  -d, --dialect <NAME>      SQL dialect [default: postgresql]
+  -f, --format <FORMAT>     Output format: human, json, sarif [default: human]
+      --max-errors <N>      Maximum number of errors before stopping [default: 100]
+  -v, --verbose             Enable verbose output
+  -q, --quiet               Suppress non-error output
+  -h, --help                Print help
+```
+
+## Output Formats
+
+### Human (default)
+
+```
+error[E0002]: Column 'user_id' not found in table 'users'
+  --> queries/fetch.sql:3:12
+   |
+ 3 |   WHERE users.user_id = $1
+   |              ^^^^^^^^^
+   |
+   = help: Did you mean 'id'?
+```
+
+### JSON
+
+```bash
+sqlsift check -s schema.sql -f json queries/*.sql
+```
+
+### SARIF (for GitHub Code Scanning)
+
+```bash
+sqlsift check -s schema.sql -f sarif queries/*.sql > results.sarif
+```
+
+## Supported SQL Queries
+
+- SELECT, INSERT, UPDATE, DELETE with full column/table validation
+- JOINs (INNER, LEFT, RIGHT, FULL, CROSS, NATURAL) with ON/USING clause validation
+- CTEs (WITH clause) including recursive CTEs
+- Subqueries (WHERE IN/EXISTS, FROM derived tables, scalar subqueries)
+- LATERAL vs non-LATERAL scope isolation
+- UPDATE ... FROM / DELETE ... USING (PostgreSQL extensions)
+- Window functions (OVER, PARTITION BY, FILTER)
+- GROUPING SETS, CUBE, ROLLUP
+- DISTINCT ON, UNION / INTERSECT / EXCEPT
+- ORDER BY with SELECT alias support
+- Comprehensive expression coverage (CASE, CAST, JSON operators, AT TIME ZONE, ARRAY, etc.)
+
+## Supported DDL
+
+- `CREATE TABLE` (columns, constraints, primary keys, foreign keys, UNIQUE)
+- `CREATE VIEW` (column inference from SELECT projection)
+- `CREATE TYPE AS ENUM`
+- `ALTER TABLE` (ADD/DROP/RENAME COLUMN, ADD CONSTRAINT, RENAME TABLE)
+- `CHECK` constraints (column-level and table-level)
+- `GENERATED AS IDENTITY` columns (ALWAYS / BY DEFAULT)
+- Resilient parsing — unsupported DDL (functions, triggers, domains, etc.) is gracefully skipped
+
+## Supported SQL Dialects
+
+- **PostgreSQL** (default) — fully supported
+- **MySQL** — supported (`--dialect mysql`)
+- **SQLite** — supported (`--dialect sqlite`)
+
+Use the `--dialect` flag to specify the dialect.
+
+## Roadmap
+
+### Completed
+- [x] Configuration file (`sqlsift.toml`)
+- [x] MySQL dialect support
+- [x] SQLite dialect support
+- [x] Type inference for expressions (WHERE, JOIN, arithmetic, INSERT/UPDATE)
+- [x] LSP server for editor integration (VS Code extension)
+
+### Planned
+- [ ] CAST expression type inference
+- [ ] Function return type inference (COUNT, SUM, AVG, etc.)
+- [ ] CASE expression type consistency checking
+- [ ] Subquery/CTE column type inference
+- [ ] Custom rule plugins
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Run tests (`cargo test`)
+4. Commit your changes (`git commit -m 'Add amazing feature'`)
+5. Push to the branch (`git push origin feature/amazing-feature`)
+6. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- [sqlparser-rs](https://github.com/apache/datafusion-sqlparser-rs) — SQL parsing
+- [miette](https://github.com/zkat/miette) — Diagnostic rendering
+- [clap](https://github.com/clap-rs/clap) — CLI framework

package/binary-install.js

@@ -0,0 +1,212 @@
+const { createWriteStream, existsSync, mkdirSync, mkdtemp } = require("fs");
+const { join, sep } = require("path");
+const { spawnSync } = require("child_process");
+const { tmpdir } = require("os");
+
+const axios = require("axios");
+const rimraf = require("rimraf");
+const tmpDir = tmpdir();
+
+const error = (msg) => {
+  console.error(msg);
+  process.exit(1);
+};
+
+class Package {
+  constructor(platform, name, url, filename, zipExt, binaries) {
+    let errors = [];
+    if (typeof url !== "string") {
+      errors.push("url must be a string");
+    } else {
+      try {
+        new URL(url);
+      } catch (e) {
+        errors.push(e);
+      }
+    }
+    if (name && typeof name !== "string") {
+      errors.push("package name must be a string");
+    }
+    if (!name) {
+      errors.push("You must specify the name of your package");
+    }
+    if (binaries && typeof binaries !== "object") {
+      errors.push("binaries must be a string => string map");
+    }
+    if (!binaries) {
+      errors.push("You must specify the binaries in the package");
+    }
+
+    if (errors.length > 0) {
+      let errorMsg =
+        "One or more of the parameters you passed to the Binary constructor are invalid:\n";
+      errors.forEach((error) => {
+        errorMsg += error;
+      });
+      errorMsg +=
+        '\n\nCorrect usage: new Package("my-binary", "https://example.com/binary/download.tar.gz", {"my-binary": "my-binary"})';
+      error(errorMsg);
+    }
+
+    this.platform = platform;
+    this.url = url;
+    this.name = name;
+    this.filename = filename;
+    this.zipExt = zipExt;
+    this.installDirectory = join(__dirname, "node_modules", ".bin_real");
+    this.binaries = binaries;
+
+    if (!existsSync(this.installDirectory)) {
+      mkdirSync(this.installDirectory, { recursive: true });
+    }
+  }
+
+  exists() {
+    for (const binaryName in this.binaries) {
+      const binRelPath = this.binaries[binaryName];
+      const binPath = join(this.installDirectory, binRelPath);
+      if (!existsSync(binPath)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  install(fetchOptions, suppressLogs = false) {
+    if (this.exists()) {
+      if (!suppressLogs) {
+        console.error(
+          `${this.name} is already installed, skipping installation.`,
+        );
+      }
+      return Promise.resolve();
+    }
+
+    if (existsSync(this.installDirectory)) {
+      rimraf.sync(this.installDirectory);
+    }
+
+    mkdirSync(this.installDirectory, { recursive: true });
+
+    if (!suppressLogs) {
+      console.error(`Downloading release from ${this.url}`);
+    }
+
+    return axios({ ...fetchOptions, url: this.url, responseType: "stream" })
+      .then((res) => {
+        return new Promise((resolve, reject) => {
+          mkdtemp(`${tmpDir}${sep}`, (err, directory) => {
+            let tempFile = join(directory, this.filename);
+            const sink = res.data.pipe(createWriteStream(tempFile));
+            sink.on("error", (err) => reject(err));
+            sink.on("close", () => {
+              if (/\.tar\.*/.test(this.zipExt)) {
+                const result = spawnSync("tar", [
+                  "xf",
+                  tempFile,
+                  // The tarballs are stored with a leading directory
+                  // component; we strip one component in the
+                  // shell installers too.
+                  "--strip-components",
+                  "1",
+                  "-C",
+                  this.installDirectory,
+                ]);
+                if (result.status == 0) {
+                  resolve();
+                } else if (result.error) {
+                  reject(result.error);
+                } else {
+                  reject(
+                    new Error(
+                      `An error occurred untarring the artifact: stdout: ${result.stdout}; stderr: ${result.stderr}`,
+                    ),
+                  );
+                }
+              } else if (this.zipExt == ".zip") {
+                let result;
+                if (this.platform.artifactName.includes("windows")) {
+                  // Windows does not have "unzip" by default on many installations, instead
+                  // we use Expand-Archive from powershell
+                  result = spawnSync("powershell.exe", [
+                    "-NoProfile",
+                    "-NonInteractive",
+                    "-Command",
+                    `& {
+                        param([string]$LiteralPath, [string]$DestinationPath)
+                        Expand-Archive -LiteralPath $LiteralPath -DestinationPath $DestinationPath -Force
+                    }`,
+                    tempFile,
+                    this.installDirectory,
+                  ]);
+                } else {
+                  result = spawnSync("unzip", [
+                    "-q",
+                    tempFile,
+                    "-d",
+                    this.installDirectory,
+                  ]);
+                }
+
+                if (result.status == 0) {
+                  resolve();
+                } else if (result.error) {
+                  reject(result.error);
+                } else {
+                  reject(
+                    new Error(
+                      `An error occurred unzipping the artifact: stdout: ${result.stdout}; stderr: ${result.stderr}`,
+                    ),
+                  );
+                }
+              } else {
+                reject(
+                  new Error(`Unrecognized file extension: ${this.zipExt}`),
+                );
+              }
+            });
+          });
+        });
+      })
+      .then(() => {
+        if (!suppressLogs) {
+          console.error(`${this.name} has been installed!`);
+        }
+      })
+      .catch((e) => {
+        error(`Error fetching release: ${e.message}`);
+      });
+  }
+
+  run(binaryName, fetchOptions) {
+    const promise = !this.exists()
+      ? this.install(fetchOptions, true)
+      : Promise.resolve();
+
+    promise
+      .then(() => {
+        const [, , ...args] = process.argv;
+
+        const options = { cwd: process.cwd(), stdio: "inherit" };
+
+        const binRelPath = this.binaries[binaryName];
+        if (!binRelPath) {
+          error(`${binaryName} is not a known binary in ${this.name}`);
+        }
+        const binPath = join(this.installDirectory, binRelPath);
+        const result = spawnSync(binPath, args, options);
+
+        if (result.error) {
+          error(result.error);
+        }
+
+        process.exit(result.status);
+      })
+      .catch((e) => {
+        error(e.message);
+        process.exit(1);
+      });
+  }
+}
+
+module.exports.Package = Package;