airfoil 0.2.0 → 0.4.0

package/src/commands/sql.ts

@@ -1,33 +1,31 @@
-import { readFileSync } from "node:fs";
-import * as p from "@clack/prompts";
-import { Args, Command, Options } from "@effect/cli";
 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";
 
-const queryArg = Args.text({ name: "query" }).pipe(
-  Args.withDescription("SQL query to execute"),
-  Args.optional,
+import { hostOption, portOption } from "../utils/options";
+
+const queryArg = Argument.string("query").pipe(
+  Argument.withDescription("SQL query to execute"),
+  Argument.optional,
 );
 
-const fileOption = Options.text("file").pipe(
-  Options.withAlias("f"),
-  Options.withDescription("Execute SQL from file"),
-  Options.optional,
+const fileOption = Flag.string("file").pipe(
+  Flag.withAlias("f"),
+  Flag.withDescription("Execute SQL from file"),
+  Flag.optional,
 );
 
-const namespaceOption = Options.text("namespace").pipe(
-  Options.withAlias("n"),
-  Options.withDescription("Wings namespace"),
-  Options.withDefault("tenants/default/namespaces/default"),
+const namespaceOption = Flag.string("namespace").pipe(
+  Flag.withAlias("n"),
+  Flag.withDescription("Wings namespace"),
+  Flag.withDefault("tenants/default/namespaces/default"),
 );
 
-const jsonOption = Options.boolean("json").pipe(
-  Options.withDescription("Output results as JSON"),
-  Options.withDefault(false),
+const jsonOption = Flag.boolean("json").pipe(
+  Flag.withDescription("Output results as JSON"),
+  Flag.withDefault(false),
 );
 
 export const sqlCommand = Command.make(
@@ -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.catchAll(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,18 +1,27 @@
-#!/usr/bin/env bun
-import { Command } from "@effect/cli";
-import { NodeContext, NodeRuntime } from "@effect/platform-node";
+#!/usr/bin/env node
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
 import { Effect } from "effect";
-import { clusterCommand } from "./commands/cluster/index.js";
-import { devCommand } from "./commands/dev.js";
-import { sqlCommand } from "./commands/sql.js";
+import { Command } from "effect/unstable/cli";
+import { FetchHttpClient } from "effect/unstable/http";
+
+import packageJson from "../package.json";
+import { clusterCommand } from "./commands/cluster/index";
+import { devCommand } from "./commands/dev";
+import { sqlCommand } from "./commands/sql";
+
+const version = packageJson.version;
 
 const program = Command.make("airfoil", {}, () => Effect.void).pipe(
   Command.withSubcommands([devCommand, sqlCommand, clusterCommand]),
 );
 
 const cli = Command.run(program, {
-  name: "Airfoil CLI - Manage your Wings deployments",
-  version: "0.1.0",
+  version,
 });
 
-cli(process.argv).pipe(Effect.provide(NodeContext.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

@@ -1,36 +1,35 @@
-import { Options } from "@effect/cli";
+import { Flag } from "effect/unstable/cli";
 
 /**
  * Common server connection options
  */
-export const hostOption = Options.text("host").pipe(
-  Options.withDescription("Server host"),
-  Options.withDefault("localhost"),
+export const hostOption = Flag.string("host").pipe(
+  Flag.withDescription("Server host"),
+  Flag.withDefault("localhost"),
 );
 
-export const portOption = Options.integer("port").pipe(
-  Options.withDescription("Server port"),
-  Options.withAlias("p"),
-  Options.withDefault(7777),
+export const portOption = Flag.integer("port").pipe(
+  Flag.withDescription("Server port"),
+  Flag.withAlias("p"),
+  Flag.withDefault(7777),
 );
 
 /**
  * Common pagination options
  */
-export const pageSizeOption = Options.integer("page-size").pipe(
-  Options.withDescription("Number of items to return (max: 1000)"),
-  Options.withDefault(100),
+export const pageSizeOption = Flag.integer("page-size").pipe(
+  Flag.withDescription("Number of items to return (max: 1000)"),
+  Flag.withDefault(100),
 );
 
-export const pageTokenOption = Options.text("page-token").pipe(
-  Options.withDescription("Continuation token for pagination"),
-  Options.optional,
+export const pageTokenOption = Flag.optional(
+  Flag.string("page-token").pipe(Flag.withDescription("Continuation token for pagination")),
 );
 
 /**
  * Force flag for destructive operations
  */
-export const forceOption = Options.boolean("force").pipe(
-  Options.withDescription("Skip confirmation prompt"),
-  Options.withDefault(false),
+export const forceOption = Flag.boolean("force").pipe(
+  Flag.withDescription("Skip confirmation prompt"),
+  Flag.withDefault(false),
 );

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)),
-    ),
-  );