airfoil 0.3.0 → 0.4.0

package/src/commands/dev.ts

@@ -1,8 +1,9 @@
-import * as p from "@clack/prompts";
-import { Effect } from "effect";
-import { Command, Flag } from "effect/unstable/cli";
-import { handleCliError } from "../utils/effect.js";
-import { downloadWings, getWingsPath, verifyChecksum } from "../utils/wings.js";
+import { Effect, FileSystem } from "effect";
+import { Command, Flag, Prompt } from "effect/unstable/cli";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+
+import { checkDockerVersion, createDockerVolume, runDockerContainer } from "../utils/docker";
+import { downloadWings, getWingsPath } from "../utils/wings";
 
 const dockerOption = Flag.boolean("docker").pipe(
   Flag.withDescription("Run Wings using Docker (recommended)"),
@@ -10,9 +11,7 @@ const dockerOption = Flag.boolean("docker").pipe(
 );
 
 const versionOption = Flag.string("version").pipe(
-  Flag.withDescription(
-    "Specify Wings version (e.g., v0.1.0-alpha.11 or 'latest')",
-  ),
+  Flag.withDescription("Specify Wings version (e.g., v0.1.0-alpha.11 or 'latest')"),
   Flag.withDefault("latest"),
 );
 
@@ -47,189 +46,87 @@ export const devCommand = Command.make(
     stress: stressOption,
     yes: yesOption,
   },
-  (options) =>
-    Effect.tryPromise({
-      try: () =>
-        options.docker ? runWithDocker(options) : runWithBinary(options),
-      catch: (error) =>
-        error instanceof Error ? error : new Error("Operation failed"),
-    }).pipe(Effect.catch(handleCliError("Operation failed"))),
+  (options) => (options.docker ? runWithDocker(options) : runWithBinary(options)),
 ).pipe(
   Command.withDescription(
     "Download and run Wings dev server locally (Docker recommended for portability)",
   ),
 );
 
-async function runWithBinary(options: {
-  version: string;
-  yes: boolean;
-  stress: boolean;
-}) {
-  p.intro("🪽 Airfoil Dev");
-
-  const version = options.version;
-  const isStress = options.stress;
-  const wingsPath = getWingsPath(version, isStress);
-  const fileExists = await Bun.file(wingsPath).exists();
-
-  if (!fileExists) {
-    p.log.warn(
-      `Wings${isStress ? " stress" : ""} binary not found for version ${version}`,
-    );
-
-    if (!options.yes) {
-      const confirm = await p.confirm({
-        message: `Download Wings${isStress ? " stress" : ""} ${version} binary? (~100MB)`,
-        initialValue: true,
-      });
-
-      if (p.isCancel(confirm) || !confirm) {
-        p.cancel("Download cancelled");
-        process.exit(0);
-      }
-    }
+const runWithBinary = (options: { version: string; yes: boolean; stress: boolean }) =>
+  Effect.gen(function* () {
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+    const fs = yield* FileSystem.FileSystem;
 
-    const s = p.spinner();
-    s.start(`Downloading Wings${isStress ? " stress" : ""} ${version}...`);
+    yield* Effect.logInfo("🪽 Airfoil Dev");
 
-    try {
-      await downloadWings(version, wingsPath, isStress);
-      s.stop(`Downloaded Wings${isStress ? " stress" : ""} ${version}`);
-    } catch (error) {
-      s.stop("Download failed");
-      throw error;
-    }
+    const version = options.version;
+    const isStress = options.stress;
+    const wingsPath = yield* getWingsPath(version, isStress);
+    const exists = yield* fs.exists(wingsPath);
 
-    const s2 = p.spinner();
-    s2.start("Verifying checksum...");
+    if (!exists) {
+      yield* Effect.logWarning(
+        `Wings${isStress ? " stress" : ""} binary not found for version ${version}`,
+      );
 
-    try {
-      const isValid = await verifyChecksum(version, wingsPath, isStress);
+      if (!options.yes) {
+        const confirm = yield* Prompt.confirm({
+          message: `Download Wings${isStress ? " stress" : ""} ${version} binary? (~100MB)`,
+          initial: true,
+        });
 
-      if (!isValid) {
-        s2.stop("Checksum verification failed");
-        throw new Error(
-          "Binary checksum does not match expected value. This could indicate a corrupted download or security issue.",
-        );
+        if (!confirm) {
+          return yield* Effect.fail(new Error("Download cancelled"));
+        }
       }
 
-      s2.stop("Checksum verified ✓");
-    } catch (error) {
-      s2.stop("Checksum verification failed");
-      throw error;
+      yield* Effect.logInfo(`Downloading Wings${isStress ? " stress" : ""} ${version}...`);
+
+      yield* downloadWings(version, wingsPath, isStress);
+    } else {
+      yield* Effect.logInfo(`Using cached Wings${isStress ? " stress" : ""} binary (${version})`);
     }
 
-    await Bun.$`chmod +x ${wingsPath}`;
-  } else {
-    p.log.success(
-      `Using cached Wings${isStress ? " stress" : ""} binary (${version})`,
-    );
-  }
+    yield* Effect.logInfo(`Starting Wings dev server...`);
+
+    const proc = ChildProcess.make(wingsPath, ["dev"], {
+      stdin: "inherit",
+      stdout: "inherit",
+    });
 
-  p.log.info("Starting Wings dev server...");
+    const handle = yield* spawner.spawn(proc);
 
-  const proc = Bun.spawn([wingsPath, "dev"], {
-    stdout: "inherit",
-    stderr: "inherit",
-    stdin: "inherit",
-  });
+    const exitCode = yield* handle.exitCode;
 
-  await proc.exited;
-}
-
-async function runWithDocker(options: { tag: string; forcePull: boolean }) {
-  p.intro("🐳 Airfoil Dev (Docker)");
-
-  let tag = options.tag;
-
-  // If tag is not "latest" and doesn't include architecture, append it
-  // Format: 0.1.0-alpha.10-aarch64 or 0.1.0-alpha.10-x86_64
-  if (tag !== "latest" && !tag.includes("aarch64") && !tag.includes("x86_64")) {
-    const arch = process.arch === "arm64" ? "aarch64" : "x86_64";
-    // Remove 'v' prefix if present for docker tags
-    const cleanTag = tag.startsWith("v") ? tag.substring(1) : tag;
-    tag = `${cleanTag}-${arch}`;
-  }
-
-  const image = `docker.useairfoil.com/airfoil/wings:${tag}`;
-
-  p.log.info(`Using Docker image: ${image}`);
-  p.log.info("Ports: 7777 (metadata), 7780 (http)");
-
-  try {
-    await Bun.$`docker --version`.quiet();
-  } catch {
-    p.cancel(
-      "Docker is not installed or not running. Please install Docker first.",
-    );
-    process.exit(1);
-  }
-
-  let imageExists = false;
-  if (!options.forcePull) {
-    try {
-      const result = await Bun.$`docker images -q ${image}`.text();
-      imageExists = result.trim().length > 0;
-    } catch {
-      imageExists = false;
+    if (exitCode !== 0) {
+      yield* Effect.fail(new Error(`Process exited with code ${exitCode}`));
     }
-  }
-
-  if (!imageExists || options.forcePull) {
-    const s = p.spinner();
-    s.start(
-      options.forcePull
-        ? "Pulling latest Docker image..."
-        : "Downloading Docker image...",
-    );
-
-    try {
-      await Bun.$`docker pull ${image}`.quiet();
-      s.stop("Docker image ready");
-    } catch {
-      s.stop("Failed to pull image");
-      p.cancel(
-        "Could not download Docker image. Please check your internet connection and registry access.",
-      );
-      process.exit(1);
+  });
+
+const runWithDocker = (options: { tag: string; forcePull: boolean }) =>
+  Effect.gen(function* () {
+    yield* Effect.logInfo("🐳 Airfoil Dev (Docker)");
+
+    let tag = options.tag;
+
+    // If tag is not "latest" and doesn't include architecture, append it
+    // Format: 0.1.0-alpha.10-aarch64 or 0.1.0-alpha.10-x86_64
+    if (tag !== "latest" && !tag.includes("aarch64") && !tag.includes("x86_64")) {
+      const arch = process.arch === "arm64" ? "aarch64" : "x86_64";
+      // Remove 'v' prefix if present for docker tags
+      const cleanTag = tag.startsWith("v") ? tag.substring(1) : tag;
+      tag = `${cleanTag}-${arch}`;
     }
-  } else {
-    p.log.success("Using cached Docker image");
-  }
-
-  try {
-    await Bun.$`docker volume create wings-data`.quiet();
-  } catch {
-    // volume may already exist, that's fine
-  }
-
-  p.log.info("Starting Wings dev server...");
-
-  const proc = Bun.spawn(
-    [
-      "docker",
-      "run",
-      "-it",
-      "--rm",
-      "--name",
-      "wings-dev",
-      "-v",
-      "wings-data:/tmp",
-      "-p",
-      "7777:7777",
-      "-p",
-      "7780:7780",
-      image,
-      "dev",
-      "--http.address=0.0.0.0:7780",
-      "--metadata.address=0.0.0.0:7777",
-    ],
-    {
-      stdout: "inherit",
-      stderr: "inherit",
-      stdin: "inherit",
-    },
-  );
 
-  await proc.exited;
-}
+    const image = `docker.useairfoil.com/airfoil/wings:${tag}`;
+
+    yield* Effect.logInfo(`Using Docker image: ${image}`);
+    yield* Effect.logInfo("Ports: 7777 (gRPC), 7780 (http)");
+
+    yield* checkDockerVersion();
+
+    yield* createDockerVolume("wings-data");
+
+    yield* runDockerContainer(image, "wings-data");
+  });

package/src/commands/sql.ts

@@ -1,12 +1,10 @@
-import { readFileSync } from "node:fs";
-import * as p from "@clack/prompts";
 import { ArrowFlightSqlClient } from "@useairfoil/flight";
 import { printTable } from "console-table-printer";
-import { Effect, Option } from "effect";
+import { Effect, FileSystem, Option } from "effect";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 import { Metadata } from "nice-grpc-common";
-import { handleCliError } from "../utils/effect.js";
-import { hostOption, portOption } from "../utils/options.js";
+
+import { hostOption, portOption } from "../utils/options";
 
 const queryArg = Argument.string("query").pipe(
   Argument.withDescription("SQL query to execute"),
@@ -42,32 +40,23 @@ export const sqlCommand = Command.make(
   },
   ({ query, host, port, file, namespace, json }) =>
     Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
       let sqlQuery = Option.getOrUndefined(query);
       const filePath = Option.getOrUndefined(file);
 
       if (filePath) {
-        sqlQuery = yield* Effect.try({
-          try: () => readFileSync(filePath, "utf-8"),
-          catch: (error) =>
-            new Error(
-              `Failed to read file: ${error instanceof Error ? error.message : "Unknown error"}`,
-            ),
-        });
+        sqlQuery = yield* fs.readFileString(filePath);
       }
 
       if (!sqlQuery) {
         return yield* Effect.fail(
-          new Error(
-            "No query provided. Use a query argument or --file option.",
-          ),
+          new Error("No query provided. Use a query argument or --file option."),
         );
       }
 
       const hostPort = `${host}:${port}`;
 
-      p.intro("🔍 Arrow Flight SQL");
-      p.log.info(`Connecting to: ${hostPort}`);
-      p.log.info(`Namespace: ${namespace}`);
+      yield* Effect.logInfo(`Namespace: ${namespace}`);
 
       const client = new ArrowFlightSqlClient(
         {
@@ -84,38 +73,28 @@ export const sqlCommand = Command.make(
         },
       );
 
-      const s = p.spinner();
-      s.start("Executing query...");
-
       const flightInfo = yield* Effect.tryPromise({
         try: () => client.executeQuery({ query: sqlQuery }),
-        catch: (error) =>
-          error instanceof Error ? error : new Error("Query failed"),
-      }).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Query failed"))));
+        catch: (error) => (error instanceof Error ? error : new Error("Query failed")),
+      });
 
       const batches = yield* Effect.tryPromise({
         try: () => Array.fromAsync(client.executeFlightInfo(flightInfo)),
-        catch: (error) =>
-          error instanceof Error ? error : new Error("Query failed"),
-      }).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Query failed"))));
+        catch: (error) => (error instanceof Error ? error : new Error("Query failed")),
+      });
 
       const data = batches.flatMap((batch) => batch.toArray());
 
-      s.stop(`Query executed: ${sqlQuery}`);
-
-      yield* Effect.sync(() => {
-        if (json) {
-          console.log(JSON.stringify(data, null, 2));
-        } else if (data.length === 0) {
-          p.log.warn("No results returned");
-        } else {
-          printTable(data, {
-            defaultColumnOptions: {
-              alignment: "left",
-            },
-          });
-        }
-        p.outro("✓ Done");
-      });
-    }).pipe(Effect.catch(handleCliError("Command failed"))),
+      if (json) {
+        yield* Effect.log(JSON.stringify(data, null, 2));
+      } else if (data.length === 0) {
+        yield* Effect.logWarning("No results returned");
+      } else {
+        printTable(data, {
+          defaultColumnOptions: {
+            alignment: "left",
+          },
+        });
+      }
+    }),
 ).pipe(Command.withDescription("Execute SQL queries using Arrow Flight SQL"));

package/src/index.ts

@@ -1,11 +1,13 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 import { NodeRuntime, NodeServices } from "@effect/platform-node";
 import { Effect } from "effect";
 import { Command } from "effect/unstable/cli";
+import { FetchHttpClient } from "effect/unstable/http";
+
 import packageJson from "../package.json";
-import { clusterCommand } from "./commands/cluster/index.js";
-import { devCommand } from "./commands/dev.js";
-import { sqlCommand } from "./commands/sql.js";
+import { clusterCommand } from "./commands/cluster/index";
+import { devCommand } from "./commands/dev";
+import { sqlCommand } from "./commands/sql";
 
 const version = packageJson.version;
 
@@ -17,4 +19,9 @@ const cli = Command.run(program, {
   version,
 });
 
-cli.pipe(Effect.provide(NodeServices.layer), NodeRuntime.runMain);
+cli.pipe(
+  Effect.provide(FetchHttpClient.layer),
+  Effect.provide(NodeServices.layer),
+  Effect.scoped,
+  NodeRuntime.runMain,
+);

package/src/utils/docker.ts

@@ -0,0 +1,43 @@
+import { Effect, String } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+
+export const checkDockerVersion = () =>
+  Effect.gen(function* () {
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+    const docker = ChildProcess.make("docker", ["--version"]);
+
+    return yield* spawner.string(docker).pipe(Effect.map(String.trim));
+  });
+
+export const createDockerVolume = (volumeName: string) =>
+  Effect.gen(function* () {
+    const docker = yield* ChildProcess.make("docker", ["volume", "create", volumeName]);
+    yield* docker.exitCode;
+  });
+
+export const runDockerContainer = (image: string, volumeName: string) =>
+  Effect.gen(function* () {
+    const docker = yield* ChildProcess.make("docker", [
+      "run",
+      "-it",
+      "--rm",
+      "--name",
+      "wings-dev",
+      "-v",
+      `${volumeName}:/tmp`,
+      "-p",
+      "7777:7777",
+      "-p",
+      "7780:7780",
+      image,
+      "dev",
+      "--http.address=0.0.0.0:7780",
+      "--metadata.address=0.0.0.0:7777",
+    ]);
+
+    const exitCode = yield* docker.exitCode;
+
+    if (exitCode !== 0) {
+      yield* Effect.fail(new Error(`Docker process exited with code ${exitCode}`));
+    }
+  });

package/src/utils/options.ts

@@ -23,9 +23,7 @@ export const pageSizeOption = Flag.integer("page-size").pipe(
 );
 
 export const pageTokenOption = Flag.optional(
-  Flag.string("page-token").pipe(
-    Flag.withDescription("Continuation token for pagination"),
-  ),
+  Flag.string("page-token").pipe(Flag.withDescription("Continuation token for pagination")),
 );
 
 /**

package/src/utils/wings.ts

@@ -1,8 +1,10 @@
+import { Effect, FileSystem, Path } from "effect";
+import { HttpClient, HttpClientResponse } from "effect/unstable/http";
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-const WINGS_DIR = join(homedir(), ".airfoil", "wings");
+const WINGS_DIR = join(homedir(), ".local", "share", "wings");
 const GITHUB_RELEASES_URL = "https://github.com/useairfoil/wings/releases";
 
 /**
@@ -38,79 +40,81 @@ function getPlatformString(): string {
  */
 function getBinaryFilename(isStress: boolean): string {
   const platformString = getPlatformString();
-  return isStress
-    ? `wings-stress-${platformString}`
-    : `wings-${platformString}`;
+  return isStress ? `wings-stress-${platformString}` : `wings-${platformString}`;
 }
 
-export function getWingsPath(version: string, isStress = false): string {
-  const binaryFilename = getBinaryFilename(isStress);
-  return join(WINGS_DIR, `${binaryFilename}-${version}`);
-}
+export const getWingsPath = (version: string, isStress = false) =>
+  Effect.gen(function* () {
+    const binaryFilename = getBinaryFilename(isStress);
+    const path = yield* Path.Path;
+    return path.join(WINGS_DIR, `${binaryFilename}-${version}`);
+  });
 
-export async function downloadWings(
-  version: string,
-  targetPath: string,
-  isStress = false,
-): Promise<void> {
-  const filename = getBinaryFilename(isStress);
+export const downloadWings = (version: string, targetPath: string, isStress = false) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const client = yield* HttpClient.HttpClient;
 
-  const downloadPath =
-    version === "latest" ? "latest/download" : `download/${version}`;
-  const url = `${GITHUB_RELEASES_URL}/${downloadPath}/${filename}`;
+    const filename = getBinaryFilename(isStress);
 
-  await Bun.$`mkdir -p ${WINGS_DIR}`;
+    const downloadPath = version === "latest" ? "latest/download" : `download/${version}`;
+    const url = `${GITHUB_RELEASES_URL}/${downloadPath}/${filename}`;
 
-  const response = await fetch(url);
+    yield* fs.makeDirectory(WINGS_DIR, { recursive: true });
 
-  if (!response.ok) {
-    throw new Error(
-      `Failed to download Wings from ${url}: ${response.status} ${response.statusText}`,
-    );
-  }
+    const response = yield* client.get(url);
+    const buffer = yield* HttpClientResponse.matchStatus({
+      200: (response) => response.arrayBuffer,
+      orElse: (response) => {
+        throw new Error(`Failed to download Wings from ${url}: ${response.status}`);
+      },
+    })(response);
 
-  const buffer = await response.arrayBuffer();
-  await Bun.write(targetPath, buffer);
-}
+    yield* fs.writeFile(targetPath, new Uint8Array(buffer));
+
+    yield* verifyChecksum(version, targetPath, isStress);
+
+    yield* fs.chmod(targetPath, 0o755);
+  });
 
 /**
  * Download and verify the checksum of a Wings binary
  * The hash file format is: "<hash> <path>/wings"
  */
-export async function verifyChecksum(
-  version: string,
-  filePath: string,
-  isStress = false,
-): Promise<boolean> {
-  const filename = getBinaryFilename(isStress);
-  const hashFilename = `${filename}-hash.txt`;
-
-  const downloadPath =
-    version === "latest" ? "latest/download" : `download/${version}`;
-  const hashUrl = `${GITHUB_RELEASES_URL}/${downloadPath}/${hashFilename}`;
-
-  const hashResponse = await fetch(hashUrl);
-
-  if (!hashResponse.ok) {
-    throw new Error(
-      `Failed to download hash file from ${hashUrl}: ${hashResponse.status} ${hashResponse.statusText}`,
-    );
-  }
-
-  const hashContent = await hashResponse.text();
-
-  const expectedChecksum = hashContent.trim().split(/\s+/)[0];
-
-  if (!expectedChecksum) {
-    throw new Error("Invalid hash file format");
-  }
-
-  const file = Bun.file(filePath);
-  const buffer = await file.arrayBuffer();
-
-  const hash = createHash("sha256");
-  hash.update(new Uint8Array(buffer));
-  const actualChecksum = hash.digest("hex");
-
-  return actualChecksum === expectedChecksum;
-}
+export const verifyChecksum = (version: string, filePath: string, isStress = false) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const client = yield* HttpClient.HttpClient;
+
+    const filename = getBinaryFilename(isStress);
+    const hashFilename = `${filename}-hash.txt`;
+
+    const downloadPath = version === "latest" ? "latest/download" : `download/${version}`;
+    const url = `${GITHUB_RELEASES_URL}/${downloadPath}/${hashFilename}`;
+
+    const response = yield* client.get(url);
+    const hashContent = yield* HttpClientResponse.matchStatus({
+      200: (response) => response.text,
+      orElse: (response) => {
+        return Effect.fail(
+          new Error(`Failed to download hash file from ${url}: ${response.status}`),
+        );
+      },
+    })(response);
+
+    const expectedChecksum = hashContent.trim().split(/\s+/)[0];
+
+    if (!expectedChecksum) {
+      return yield* Effect.fail(new Error("Invalid hash file format"));
+    }
+
+    const fileBuffer = yield* fs.readFile(filePath);
+
+    const hash = createHash("sha256");
+    hash.update(fileBuffer);
+    const actualChecksum = hash.digest("hex");
+
+    if (actualChecksum !== expectedChecksum) {
+      return yield* Effect.fail(new Error("Wings binary checksum mismatch"));
+    }
+  });

package/src/scripts/compile-all.ts

@@ -1,21 +0,0 @@
-import { $ } from "bun";
-
-const targets = [
-  { platform: "linux", arch: "x64" },
-  { platform: "linux", arch: "arm64" },
-  { platform: "darwin", arch: "x64" },
-  { platform: "darwin", arch: "arm64" },
-  { platform: "windows", arch: "x64" },
-];
-
-for (const { platform, arch } of targets) {
-  const outfile = `dist/airfoil-${platform}-${arch}${platform === "windows" ? ".exe" : ""}`;
-
-  console.log(`Compiling for ${platform}-${arch}...`);
-
-  await $`bun build src/index.ts --compile --target=bun-${platform}-${arch} --outfile ${outfile}`;
-
-  console.log(`✓ Created ${outfile}`);
-}
-
-console.log("\n✓ All binaries compiled successfully!");

package/src/utils/effect.ts

@@ -1,11 +0,0 @@
-import * as p from "@clack/prompts";
-import { Effect } from "effect";
-
-export const handleCliError = (fallbackMessage: string) => (error: unknown) =>
-  Effect.sync(() => {
-    p.cancel(error instanceof Error ? error.message : fallbackMessage);
-  }).pipe(
-    Effect.andThen(
-      Effect.fail(error instanceof Error ? error : new Error(fallbackMessage)),
-    ),
-  );