airfoil 0.3.0 → 0.4.1

package/src/commands/dev.ts

@@ -1,8 +1,14 @@
-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 } from "effect/unstable/process";
+
+import {
+  checkDockerVersion,
+  createDockerVolume,
+  pullDockerImage,
+  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 +16,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.14 or 'latest')"),
   Flag.withDefault("latest"),
 );
 
@@ -47,189 +51,86 @@ 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 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...`);
 
-  p.log.info("Starting Wings dev server...");
+    const handle = yield* ChildProcess.make(wingsPath, ["dev"], {
+      stdin: "inherit",
+      stdout: "inherit",
+    });
+
+    const exitCode = yield* handle.exitCode;
 
-  const proc = Bun.spawn([wingsPath, "dev"], {
-    stdout: "inherit",
-    stderr: "inherit",
-    stdin: "inherit",
+    if (exitCode !== 0) {
+      return yield* Effect.fail(new Error(`Process exited with code ${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;
+const runWithDocker = (options: { tag: string; forcePull: boolean }) =>
+  Effect.gen(function* () {
+    yield* Effect.logInfo("🐳 Airfoil Dev (Docker)");
+
+    let tag = options.tag;
+
+    if (tag !== "latest" && !tag.includes("aarch64") && !tag.includes("x86_64")) {
+      const arch = process.arch === "arm64" ? "aarch64" : "x86_64";
+      const cleanTag = tag.startsWith("v") ? tag.substring(1) : tag;
+      tag = `${cleanTag}-${arch}`;
     }
-  }
-
-  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 image = `docker.useairfoil.com/airfoil/wings:${tag}`;
+
+    yield* Effect.logInfo(`Using Docker image: ${image}`);
+    yield* Effect.logInfo("Ports: 7777 (gRPC)");
+
+    yield* checkDockerVersion();
+
+    if (options.forcePull) {
+      yield* Effect.logInfo(`Pulling Docker image: ${image}`);
+      yield* pullDockerImage(image);
     }
-  } 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;
-}
+    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, Stream } 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"),
@@ -22,7 +20,7 @@ const fileOption = Flag.string("file").pipe(
 const namespaceOption = Flag.string("namespace").pipe(
   Flag.withAlias("n"),
   Flag.withDescription("Wings namespace"),
-  Flag.withDefault("tenants/default/namespaces/default"),
+  Flag.withDefault("namespaces/default"),
 );
 
 const jsonOption = Flag.boolean("json").pipe(
@@ -42,80 +40,51 @@ 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(
-        {
-          host: hostPort,
-        },
-        {
-          defaultCallOptions: {
-            "*": {
-              metadata: Metadata({
-                "x-wings-namespace": namespace,
-              }),
-            },
+      const client = yield* ArrowFlightSqlClient.make({
+        host: hostPort,
+        defaultCallOptions: {
+          "*": {
+            metadata: Metadata({
+              "x-wings-namespace": namespace,
+            }),
           },
         },
-      );
-
-      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"))));
+      });
 
-      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"))));
+      const flightInfo = yield* client.executeQuery({ query: sqlQuery });
 
-      const data = batches.flatMap((batch) => batch.toArray());
+      const batches = yield* client.executeFlightInfo(flightInfo).pipe(Stream.runCollect);
 
-      s.stop(`Query executed: ${sqlQuery}`);
+      const data = Array.from(batches).flatMap(({ batch }) => batch.toArray());
 
-      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 { Effect, Layer } 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);
+NodeRuntime.runMain(
+  cli.pipe(
+    Effect.provide(Layer.mergeAll(FetchHttpClient.layer, NodeServices.layer)),
+    Effect.scoped,
+  ),
+);

package/src/utils/client.ts

@@ -1,6 +1,6 @@
-import { WingsClusterMetadata } from "@useairfoil/wings";
+import { ClusterClient } from "@useairfoil/wings";
 
-export const makeClusterMetadataLayer = (host: string, port: number) =>
-  WingsClusterMetadata.layer({
+export const makeClusterClientLayer = (host: string, port: number) =>
+  ClusterClient.layer({
     host: `${host}:${port}`,
   });

package/src/utils/docker.ts

@@ -0,0 +1,137 @@
+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]);
+    const exitCode = yield* docker.exitCode;
+    if (exitCode !== 0) {
+      return yield* Effect.fail(new Error(`Docker volume create failed with code ${exitCode}`));
+    }
+  });
+
+export const createDockerNetwork = (networkName: string) =>
+  Effect.gen(function* () {
+    const docker = yield* ChildProcess.make("docker", ["network", "create", networkName]);
+    const exitCode = yield* docker.exitCode;
+    if (exitCode !== 0) {
+      return yield* Effect.fail(new Error(`Docker network create failed with code ${exitCode}`));
+    }
+  });
+
+export const removeDockerContainer = (containerName: string) =>
+  Effect.gen(function* () {
+    const docker = yield* ChildProcess.make("docker", ["rm", "-f", containerName], {
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    yield* docker.exitCode;
+  });
+
+export const removeDockerNetwork = (networkName: string) =>
+  Effect.gen(function* () {
+    const docker = yield* ChildProcess.make("docker", ["network", "rm", networkName], {
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    yield* docker.exitCode;
+  });
+
+export const pullDockerImage = (image: string) =>
+  Effect.gen(function* () {
+    const docker = yield* ChildProcess.make("docker", ["pull", image], {
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+    const exitCode = yield* docker.exitCode;
+    if (exitCode !== 0) {
+      return yield* Effect.fail(new Error(`Docker pull failed with code ${exitCode}`));
+    }
+  });
+
+export const runDockerContainer = (image: string, volumeName: string) =>
+  Effect.gen(function* () {
+    const networkName = "airfoil-dev";
+    const seaweedContainerName = "airfoil-seaweedfs";
+
+    yield* removeDockerContainer(seaweedContainerName);
+    yield* removeDockerNetwork(networkName);
+    yield* createDockerNetwork(networkName);
+    yield* Effect.addFinalizer(() =>
+      removeDockerNetwork(networkName).pipe(Effect.catchCause(() => Effect.void)),
+    );
+
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+    const seaweed = ChildProcess.make("docker", [
+      "run",
+      "-d",
+      "--rm",
+      "--name",
+      seaweedContainerName,
+      "--network",
+      networkName,
+      "--network-alias",
+      "seaweedfs",
+      "-e",
+      "AWS_ACCESS_KEY_ID=wingsdevaccesskey",
+      "-e",
+      "AWS_SECRET_ACCESS_KEY=wingsdevsecretkey",
+      "-e",
+      "S3_BUCKET=default-bucket",
+      "-v",
+      `${volumeName}:/data`,
+      "-p",
+      "8333:8333",
+      "chrislusf/seaweedfs:4.29",
+      "weed",
+      "mini",
+      "-s3",
+      "-dir=/data",
+    ]);
+
+    yield* spawner.string(seaweed).pipe(Effect.map(String.trim));
+    yield* Effect.addFinalizer(() =>
+      removeDockerContainer(seaweedContainerName).pipe(Effect.catchCause(() => Effect.void)),
+    );
+
+    const docker = yield* ChildProcess.make("docker", [
+      "run",
+      "-it",
+      "--rm",
+      "--name",
+      "wings-dev",
+      "--network",
+      networkName,
+      "-e",
+      "AWS_ACCESS_KEY_ID=wingsdevaccesskey",
+      "-e",
+      "AWS_SECRET_ACCESS_KEY=wingsdevsecretkey",
+      "-e",
+      "AWS_ENDPOINT=http://seaweedfs:8333",
+      "-e",
+      "AWS_BUCKET_NAME=default-bucket",
+      "-e",
+      "AWS_DEFAULT_REGION=us-east-1",
+      "-e",
+      "AWS_ALLOW_HTTP=true",
+      "-p",
+      "7777:7777",
+      image,
+      "dev",
+      "--grpc.address=0.0.0.0:7777",
+    ]);
+
+    const exitCode = yield* docker.exitCode;
+
+    if (exitCode !== 0) {
+      return yield* Effect.fail(new Error(`Docker process exited with code ${exitCode}`));
+    }
+  });

package/src/utils/options.ts

@@ -5,7 +5,7 @@ import { Flag } from "effect/unstable/cli";
  */
 export const hostOption = Flag.string("host").pipe(
   Flag.withDescription("Server host"),
-  Flag.withDefault("localhost"),
+  Flag.withDefault("127.0.0.1"),
 );
 
 export const portOption = Flag.integer("port").pipe(
@@ -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")),
 );
 
 /**