airfoil 0.1.0

package/src/commands/cluster/topic/get.ts

@@ -0,0 +1,51 @@
+import { WingsClusterMetadata } from "@airfoil/wings";
+import * as p from "@clack/prompts";
+import { Command, Options } from "@effect/cli";
+import { printTable } from "console-table-printer";
+import { Effect } from "effect";
+import { makeClusterMetadataLayer } from "../../../utils/client.js";
+import { handleCliError } from "../../../utils/effect.js";
+import { hostOption, portOption } from "../../../utils/options.js";
+
+const nameOption = Options.text("name").pipe(
+  Options.withDescription(
+    "Topic name in format: tenants/{tenant}/namespaces/{namespace}/topics/{topic}",
+  ),
+);
+
+export const getTopicCommand = Command.make(
+  "get-topic",
+  {
+    name: nameOption,
+    host: hostOption,
+    port: portOption,
+  },
+  ({ name, host, port }) =>
+    Effect.gen(function* () {
+      const layer = makeClusterMetadataLayer(host, port);
+
+      const s = p.spinner();
+      s.start("Fetching topic...");
+
+      const topic = yield* WingsClusterMetadata.getTopic({ name }).pipe(
+        Effect.provide(layer),
+        Effect.tapError(() => Effect.sync(() => s.stop("Failed to get topic"))),
+      );
+
+      s.stop("Topic retrieved");
+
+      yield* Effect.sync(() => {
+        printTable([
+          {
+            name: topic.name,
+            description: topic.description || "-",
+            partition_key: topic.partitionKey?.toString() || "-",
+            freshness_seconds: topic.compaction.freshnessSeconds.toString(),
+            ttl_seconds: topic.compaction.ttlSeconds?.toString() || "-",
+          },
+        ]);
+
+        p.outro("✓ Done");
+      });
+    }).pipe(Effect.catchAll(handleCliError("Failed to get topic"))),
+).pipe(Command.withDescription("Get details of a specific topic"));

package/src/commands/cluster/topic/list.ts

@@ -0,0 +1,76 @@
+import { WingsClusterMetadata } from "@airfoil/wings";
+import * as p from "@clack/prompts";
+import { Command, Options } from "@effect/cli";
+import { printTable } from "console-table-printer";
+import { Effect, Option } from "effect";
+import { makeClusterMetadataLayer } from "../../../utils/client.js";
+import { handleCliError } from "../../../utils/effect.js";
+import {
+  hostOption,
+  pageSizeOption,
+  pageTokenOption,
+  portOption,
+} from "../../../utils/options.js";
+
+const parentOption = Options.text("parent").pipe(
+  Options.withDescription(
+    "Parent namespace in format: tenants/{tenant}/namespaces/{namespace}",
+  ),
+);
+
+export const listTopicsCommand = Command.make(
+  "list-topics",
+  {
+    parent: parentOption,
+    pageSize: pageSizeOption,
+    pageToken: pageTokenOption,
+    host: hostOption,
+    port: portOption,
+  },
+  ({ parent, pageSize, pageToken, host, port }) =>
+    Effect.gen(function* () {
+      const layer = makeClusterMetadataLayer(host, port);
+
+      const s = p.spinner();
+      s.start("Fetching topics...");
+
+      const response = yield* WingsClusterMetadata.listTopics({
+        parent,
+        pageSize,
+        pageToken: Option.getOrUndefined(pageToken),
+      }).pipe(
+        Effect.provide(layer),
+        Effect.tapError(() =>
+          Effect.sync(() => s.stop("Failed to list topics")),
+        ),
+      );
+
+      s.stop(`Found ${response.topics.length} topic(s)`);
+
+      yield* Effect.sync(() => {
+        if (response.topics.length === 0) {
+          p.log.warn("No topics found");
+        } else {
+          printTable(
+            response.topics.map(
+              (topic: {
+                name: string;
+                description?: string | null;
+                partitionKey?: number | null;
+              }) => ({
+                name: topic.name,
+                description: topic.description || "-",
+                partition_key: topic.partitionKey?.toString() || "-",
+              }),
+            ),
+          );
+        }
+
+        if (response.nextPageToken) {
+          p.log.info(`Next page token: ${response.nextPageToken}`);
+        }
+
+        p.outro("✓ Done");
+      });
+    }).pipe(Effect.catchAll(handleCliError("Failed to list topics"))),
+).pipe(Command.withDescription("List all topics belonging to a namespace"));

package/src/commands/dev.ts

@@ -0,0 +1,235 @@
+import * as p from "@clack/prompts";
+import { Command, Options } from "@effect/cli";
+import { Effect } from "effect";
+import { handleCliError } from "../utils/effect.js";
+import { downloadWings, getWingsPath, verifyChecksum } from "../utils/wings.js";
+
+const dockerOption = Options.boolean("docker").pipe(
+  Options.withDescription("Run Wings using Docker (recommended)"),
+  Options.withDefault(false),
+);
+
+const versionOption = Options.text("version").pipe(
+  Options.withDescription(
+    "Specify Wings version (e.g., v0.1.0-alpha.11 or 'latest')",
+  ),
+  Options.withDefault("latest"),
+);
+
+const tagOption = Options.text("tag").pipe(
+  Options.withDescription("Docker image tag (only with --docker)"),
+  Options.withDefault("latest"),
+);
+
+const forcePullOption = Options.boolean("force-pull").pipe(
+  Options.withDescription("Force pull Docker image even if it exists locally"),
+  Options.withDefault(false),
+);
+
+const stressOption = Options.boolean("stress").pipe(
+  Options.withDescription("Use Wings stress binary variant"),
+  Options.withDefault(false),
+);
+
+const yesOption = Options.boolean("yes").pipe(
+  Options.withAlias("y"),
+  Options.withDescription("Skip confirmation prompts"),
+  Options.withDefault(false),
+);
+
+export const devCommand = Command.make(
+  "dev",
+  {
+    docker: dockerOption,
+    version: versionOption,
+    tag: tagOption,
+    forcePull: forcePullOption,
+    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.catchAll(handleCliError("Operation failed"))),
+).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 s = p.spinner();
+    s.start(`Downloading Wings${isStress ? " stress" : ""} ${version}...`);
+
+    try {
+      await downloadWings(version, wingsPath, isStress);
+      s.stop(`Downloaded Wings${isStress ? " stress" : ""} ${version}`);
+    } catch (error) {
+      s.stop("Download failed");
+      throw error;
+    }
+
+    const s2 = p.spinner();
+    s2.start("Verifying checksum...");
+
+    try {
+      const isValid = await verifyChecksum(version, wingsPath, isStress);
+
+      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.",
+        );
+      }
+
+      s2.stop("Checksum verified ✓");
+    } catch (error) {
+      s2.stop("Checksum verification failed");
+      throw error;
+    }
+
+    await Bun.$`chmod +x ${wingsPath}`;
+  } else {
+    p.log.success(
+      `Using cached Wings${isStress ? " stress" : ""} binary (${version})`,
+    );
+  }
+
+  p.log.info("Starting Wings dev server...");
+
+  const proc = Bun.spawn([wingsPath, "dev"], {
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "inherit",
+  });
+
+  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 (!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);
+    }
+  } 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;
+}

package/src/commands/sql.ts

@@ -0,0 +1,121 @@
+import { readFileSync } from "node:fs";
+import { ArrowFlightSqlClient } from "@airfoil/flight";
+import * as p from "@clack/prompts";
+import { Args, Command, Options } from "@effect/cli";
+import { printTable } from "console-table-printer";
+import { Effect, Option } from "effect";
+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,
+);
+
+const fileOption = Options.text("file").pipe(
+  Options.withAlias("f"),
+  Options.withDescription("Execute SQL from file"),
+  Options.optional,
+);
+
+const namespaceOption = Options.text("namespace").pipe(
+  Options.withAlias("n"),
+  Options.withDescription("Wings namespace"),
+  Options.withDefault("tenants/default/namespaces/default"),
+);
+
+const jsonOption = Options.boolean("json").pipe(
+  Options.withDescription("Output results as JSON"),
+  Options.withDefault(false),
+);
+
+export const sqlCommand = Command.make(
+  "sql",
+  {
+    query: queryArg,
+    host: hostOption,
+    port: portOption,
+    file: fileOption,
+    namespace: namespaceOption,
+    json: jsonOption,
+  },
+  ({ query, host, port, file, namespace, json }) =>
+    Effect.gen(function* () {
+      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"}`,
+            ),
+        });
+      }
+
+      if (!sqlQuery) {
+        return yield* Effect.fail(
+          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}`);
+
+      const client = new ArrowFlightSqlClient(
+        {
+          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 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"))),
+).pipe(Command.withDescription("Execute SQL queries using Arrow Flight SQL"));

package/src/index.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env bun
+import { Command } from "@effect/cli";
+import { NodeContext, NodeRuntime } 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";
+
+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",
+});
+
+cli(process.argv).pipe(Effect.provide(NodeContext.layer), NodeRuntime.runMain);

package/src/scripts/compile-all.ts

@@ -0,0 +1,21 @@
+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/client.ts

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

package/src/utils/effect.ts

@@ -0,0 +1,11 @@
+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)),
+    ),
+  );

package/src/utils/options.ts

@@ -0,0 +1,36 @@
+import { Options } from "@effect/cli";
+
+/**
+ * Common server connection options
+ */
+export const hostOption = Options.text("host").pipe(
+  Options.withDescription("Server host"),
+  Options.withDefault("localhost"),
+);
+
+export const portOption = Options.integer("port").pipe(
+  Options.withDescription("Server port"),
+  Options.withAlias("p"),
+  Options.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 pageTokenOption = Options.text("page-token").pipe(
+  Options.withDescription("Continuation token for pagination"),
+  Options.optional,
+);
+
+/**
+ * Force flag for destructive operations
+ */
+export const forceOption = Options.boolean("force").pipe(
+  Options.withDescription("Skip confirmation prompt"),
+  Options.withDefault(false),
+);

package/src/utils/wings.ts

@@ -0,0 +1,116 @@
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const WINGS_DIR = join(homedir(), ".airfoil", "wings");
+const GITHUB_RELEASES_URL = "https://github.com/useairfoil/wings/releases";
+
+/**
+ * Get the platform string for Wings binary naming
+ * Examples: "aarch64-linux", "x86_64-linux", "aarch64-macos"
+ */
+function getPlatformString(): string {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  const archMap: Record<string, string> = {
+    arm64: "aarch64",
+    x64: "x86_64",
+  };
+
+  const osMap: Record<string, string> = {
+    darwin: "macos",
+    linux: "linux",
+    win32: "windows",
+  };
+
+  const mappedArch = archMap[arch] || arch;
+  const mappedOs = osMap[platform] || platform;
+
+  return `${mappedArch}-${mappedOs}`;
+}
+
+/**
+ * Get the binary filename based on platform and stress variant
+ * Examples:
+ * - "wings-aarch64-macos"
+ * - "wings-stress-aarch64-linux"
+ */
+function getBinaryFilename(isStress: boolean): string {
+  const platformString = getPlatformString();
+  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 async function downloadWings(
+  version: string,
+  targetPath: string,
+  isStress = false,
+): Promise<void> {
+  const filename = getBinaryFilename(isStress);
+
+  const downloadPath =
+    version === "latest" ? "latest/download" : `download/${version}`;
+  const url = `${GITHUB_RELEASES_URL}/${downloadPath}/${filename}`;
+
+  await Bun.$`mkdir -p ${WINGS_DIR}`;
+
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download Wings from ${url}: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  const buffer = await response.arrayBuffer();
+  await Bun.write(targetPath, buffer);
+}
+
+/**
+ * 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;
+}