airfoil 0.1.0

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

@@ -0,0 +1,80 @@
+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 tenant in format: tenants/{tenant} (e.g., 'tenants/default')",
+  ),
+);
+
+export const listNamespacesCommand = Command.make(
+  "list-namespaces",
+  {
+    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 namespaces...");
+
+      const response = yield* WingsClusterMetadata.listNamespaces({
+        parent,
+        pageSize,
+        pageToken: Option.getOrUndefined(pageToken),
+      }).pipe(
+        Effect.provide(layer),
+        Effect.tapError(() =>
+          Effect.sync(() => s.stop("Failed to list namespaces")),
+        ),
+      );
+
+      s.stop(`Found ${response.namespaces.length} namespace(s)`);
+
+      yield* Effect.sync(() => {
+        if (response.namespaces.length === 0) {
+          p.log.warn("No namespaces found");
+        } else {
+          printTable(
+            response.namespaces.map(
+              (namespace: {
+                name: string;
+                flushSizeBytes: bigint;
+                flushIntervalMillis: bigint;
+                objectStore?: string | null;
+                dataLake?: string | null;
+              }) => ({
+                name: namespace.name,
+                flush_size_bytes: namespace.flushSizeBytes.toString(),
+                flush_interval_millis: namespace.flushIntervalMillis.toString(),
+                object_store: namespace.objectStore || "-",
+                data_lake: namespace.dataLake || "-",
+              }),
+            ),
+          );
+        }
+
+        if (response.nextPageToken) {
+          p.log.info(`Next page token: ${response.nextPageToken}`);
+        }
+
+        p.outro("✓ Done");
+      });
+    }).pipe(Effect.catchAll(handleCliError("Failed to list namespaces"))),
+).pipe(Command.withDescription("List all namespaces belonging to a tenant"));

package/src/commands/cluster/object-store/create-aws.ts

@@ -0,0 +1,108 @@
+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, portOption } from "../../../utils/options.js";
+
+const parentOption = Options.text("parent").pipe(
+  Options.withDescription("Parent tenant in format: tenants/{tenant}"),
+);
+
+const objectStoreIdOption = Options.text("object-store-id").pipe(
+  Options.withDescription("Unique identifier for the object store"),
+);
+
+const bucketNameOption = Options.text("bucket-name").pipe(
+  Options.withDescription("AWS S3 bucket name"),
+);
+
+const prefixOption = Options.text("prefix").pipe(
+  Options.withDescription("Bucket prefix (optional)"),
+  Options.optional,
+);
+
+const accessKeyIdOption = Options.text("access-key-id").pipe(
+  Options.withDescription("AWS_ACCESS_KEY_ID"),
+);
+
+const secretAccessKeyOption = Options.text("secret-access-key").pipe(
+  Options.withDescription("AWS_SECRET_ACCESS_KEY"),
+);
+
+const regionOption = Options.text("region").pipe(
+  Options.withDescription("AWS_DEFAULT_REGION (e.g., us-east-1)"),
+  Options.optional,
+);
+
+export const createObjectStoreAwsCommand = Command.make(
+  "aws",
+  {
+    parent: parentOption,
+    objectStoreId: objectStoreIdOption,
+    bucketName: bucketNameOption,
+    prefix: prefixOption,
+    accessKeyId: accessKeyIdOption,
+    secretAccessKey: secretAccessKeyOption,
+    region: regionOption,
+    host: hostOption,
+    port: portOption,
+  },
+  ({
+    parent,
+    objectStoreId,
+    bucketName,
+    prefix,
+    accessKeyId,
+    secretAccessKey,
+    region,
+    host,
+    port,
+  }) =>
+    Effect.gen(function* () {
+      p.intro("🗄️  Create AWS S3 Object Store");
+
+      const layer = makeClusterMetadataLayer(host, port);
+
+      const s = p.spinner();
+      s.start("Creating AWS S3 object store...");
+
+      const result = yield* WingsClusterMetadata.createObjectStore({
+        parent,
+        objectStoreId,
+        objectStoreConfig: {
+          _tag: "aws",
+          aws: {
+            bucketName,
+            prefix: Option.getOrUndefined(prefix),
+            accessKeyId,
+            secretAccessKey,
+            region: Option.getOrUndefined(region),
+          },
+        },
+      }).pipe(
+        Effect.provide(layer),
+        Effect.tapError(() =>
+          Effect.sync(() => s.stop("Failed to create AWS object store")),
+        ),
+      );
+
+      s.stop("AWS S3 object store created successfully");
+
+      yield* Effect.sync(() => {
+        printTable([
+          {
+            name: result.name,
+            type: "AWS S3",
+            bucket: bucketName,
+            region: Option.getOrUndefined(region) || "-",
+          },
+        ]);
+        p.outro("✓ Done");
+      });
+    }).pipe(
+      Effect.catchAll(handleCliError("Failed to create AWS object store")),
+    ),
+).pipe(Command.withDescription("Create a new AWS S3 object store"));

package/src/commands/cluster/object-store/create-azure.ts

@@ -0,0 +1,100 @@
+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, portOption } from "../../../utils/options.js";
+
+const parentOption = Options.text("parent").pipe(
+  Options.withDescription("Parent tenant in format: tenants/{tenant}"),
+);
+
+const objectStoreIdOption = Options.text("object-store-id").pipe(
+  Options.withDescription("Unique identifier for the object store"),
+);
+
+const containerNameOption = Options.text("container-name").pipe(
+  Options.withDescription("Azure container name"),
+);
+
+const prefixOption = Options.text("prefix").pipe(
+  Options.withDescription("Container prefix (optional)"),
+  Options.optional,
+);
+
+const storageAccountNameOption = Options.text("storage-account-name").pipe(
+  Options.withDescription("AZURE_STORAGE_ACCOUNT_NAME"),
+);
+
+const storageAccountKeyOption = Options.text("storage-account-key").pipe(
+  Options.withDescription("AZURE_STORAGE_ACCOUNT_KEY"),
+);
+
+export const createObjectStoreAzureCommand = Command.make(
+  "azure",
+  {
+    parent: parentOption,
+    objectStoreId: objectStoreIdOption,
+    containerName: containerNameOption,
+    prefix: prefixOption,
+    storageAccountName: storageAccountNameOption,
+    storageAccountKey: storageAccountKeyOption,
+    host: hostOption,
+    port: portOption,
+  },
+  ({
+    parent,
+    objectStoreId,
+    containerName,
+    prefix,
+    storageAccountName,
+    storageAccountKey,
+    host,
+    port,
+  }) =>
+    Effect.gen(function* () {
+      p.intro("🗄️  Create Azure Blob Storage Object Store");
+
+      const layer = makeClusterMetadataLayer(host, port);
+
+      const s = p.spinner();
+      s.start("Creating Azure object store...");
+
+      const result = yield* WingsClusterMetadata.createObjectStore({
+        parent,
+        objectStoreId,
+        objectStoreConfig: {
+          _tag: "azure",
+          azure: {
+            containerName,
+            prefix: Option.getOrUndefined(prefix),
+            storageAccountName,
+            storageAccountKey,
+          },
+        },
+      }).pipe(
+        Effect.provide(layer),
+        Effect.tapError(() =>
+          Effect.sync(() => s.stop("Failed to create Azure object store")),
+        ),
+      );
+
+      s.stop("Azure object store created successfully");
+
+      yield* Effect.sync(() => {
+        printTable([
+          {
+            name: result.name,
+            type: "Azure Blob",
+            container: containerName,
+            account: storageAccountName,
+          },
+        ]);
+        p.outro("✓ Done");
+      });
+    }).pipe(
+      Effect.catchAll(handleCliError("Failed to create Azure object store")),
+    ),
+).pipe(Command.withDescription("Create a new Azure Blob Storage object store"));

package/src/commands/cluster/object-store/create-google.ts

@@ -0,0 +1,102 @@
+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, portOption } from "../../../utils/options.js";
+
+const parentOption = Options.text("parent").pipe(
+  Options.withDescription("Parent tenant in format: tenants/{tenant}"),
+);
+
+const objectStoreIdOption = Options.text("object-store-id").pipe(
+  Options.withDescription("Unique identifier for the object store"),
+);
+
+const bucketNameOption = Options.text("bucket-name").pipe(
+  Options.withDescription("Google Cloud Storage bucket name"),
+);
+
+const prefixOption = Options.text("prefix").pipe(
+  Options.withDescription("Bucket prefix (optional)"),
+  Options.optional,
+);
+
+const serviceAccountOption = Options.text("service-account").pipe(
+  Options.withDescription("GOOGLE_SERVICE_ACCOUNT"),
+);
+
+const serviceAccountKeyOption = Options.text("service-account-key").pipe(
+  Options.withDescription("GOOGLE_SERVICE_ACCOUNT_KEY"),
+);
+
+export const createObjectStoreGoogleCommand = Command.make(
+  "google",
+  {
+    parent: parentOption,
+    objectStoreId: objectStoreIdOption,
+    bucketName: bucketNameOption,
+    prefix: prefixOption,
+    serviceAccount: serviceAccountOption,
+    serviceAccountKey: serviceAccountKeyOption,
+    host: hostOption,
+    port: portOption,
+  },
+  ({
+    parent,
+    objectStoreId,
+    bucketName,
+    prefix,
+    serviceAccount,
+    serviceAccountKey,
+    host,
+    port,
+  }) =>
+    Effect.gen(function* () {
+      p.intro("🗄️  Create Google Cloud Storage Object Store");
+
+      const layer = makeClusterMetadataLayer(host, port);
+
+      const s = p.spinner();
+      s.start("Creating Google Cloud Storage object store...");
+
+      const result = yield* WingsClusterMetadata.createObjectStore({
+        parent,
+        objectStoreId,
+        objectStoreConfig: {
+          _tag: "google",
+          google: {
+            bucketName,
+            prefix: Option.getOrUndefined(prefix),
+            serviceAccount,
+            serviceAccountKey,
+          },
+        },
+      }).pipe(
+        Effect.provide(layer),
+        Effect.tapError(() =>
+          Effect.sync(() => s.stop("Failed to create Google object store")),
+        ),
+      );
+
+      s.stop("Google Cloud Storage object store created successfully");
+
+      yield* Effect.sync(() => {
+        printTable([
+          {
+            name: result.name,
+            type: "Google Cloud",
+            bucket: bucketName,
+            service_account: serviceAccount,
+          },
+        ]);
+        p.outro("✓ Done");
+      });
+    }).pipe(
+      Effect.catchAll(handleCliError("Failed to create Google object store")),
+    ),
+).pipe(
+  Command.withDescription("Create a new Google Cloud Storage object store"),
+);

package/src/commands/cluster/object-store/create-s3.ts

@@ -0,0 +1,125 @@
+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, portOption } from "../../../utils/options.js";
+
+const parentOption = Options.text("parent").pipe(
+  Options.withDescription("Parent tenant in format: tenants/{tenant}"),
+);
+
+const objectStoreIdOption = Options.text("object-store-id").pipe(
+  Options.withDescription("Unique identifier for the object store"),
+);
+
+const bucketNameOption = Options.text("bucket-name").pipe(
+  Options.withDescription("S3 bucket name"),
+);
+
+const prefixOption = Options.text("prefix").pipe(
+  Options.withDescription("Bucket prefix (optional)"),
+  Options.optional,
+);
+
+const accessKeyIdOption = Options.text("access-key-id").pipe(
+  Options.withDescription("AWS_ACCESS_KEY_ID"),
+);
+
+const secretAccessKeyOption = Options.text("secret-access-key").pipe(
+  Options.withDescription("AWS_SECRET_ACCESS_KEY"),
+);
+
+const regionOption = Options.text("region").pipe(
+  Options.withDescription("AWS_DEFAULT_REGION"),
+  Options.optional,
+);
+
+const endpointOption = Options.text("endpoint").pipe(
+  Options.withDescription(
+    "AWS_ENDPOINT (e.g., https://nyc3.digitaloceanspaces.com)",
+  ),
+);
+
+export const createObjectStoreS3Command = Command.make(
+  "s3",
+  {
+    parent: parentOption,
+    objectStoreId: objectStoreIdOption,
+    bucketName: bucketNameOption,
+    prefix: prefixOption,
+    accessKeyId: accessKeyIdOption,
+    secretAccessKey: secretAccessKeyOption,
+    region: regionOption,
+    endpoint: endpointOption,
+    host: hostOption,
+    port: portOption,
+  },
+  ({
+    parent,
+    objectStoreId,
+    bucketName,
+    prefix,
+    accessKeyId,
+    secretAccessKey,
+    region,
+    endpoint,
+    host,
+    port,
+  }) =>
+    Effect.gen(function* () {
+      p.intro("🗄️  Create S3-Compatible Object Store");
+
+      const layer = makeClusterMetadataLayer(host, port);
+
+      const s = p.spinner();
+      s.start("Creating S3-compatible object store...");
+
+      const result = yield* WingsClusterMetadata.createObjectStore({
+        parent,
+        objectStoreId,
+        objectStoreConfig: {
+          _tag: "s3Compatible",
+          s3Compatible: {
+            bucketName,
+            prefix: Option.getOrUndefined(prefix),
+            accessKeyId,
+            secretAccessKey,
+            region: Option.getOrUndefined(region),
+            endpoint,
+          },
+        },
+      }).pipe(
+        Effect.provide(layer),
+        Effect.tapError(() =>
+          Effect.sync(() =>
+            s.stop("Failed to create S3-compatible object store"),
+          ),
+        ),
+      );
+
+      s.stop("S3-compatible object store created successfully");
+
+      yield* Effect.sync(() => {
+        printTable([
+          {
+            name: result.name,
+            type: "S3-Compatible",
+            bucket: bucketName,
+            endpoint,
+          },
+        ]);
+        p.outro("✓ Done");
+      });
+    }).pipe(
+      Effect.catchAll(
+        handleCliError("Failed to create S3-compatible object store"),
+      ),
+    ),
+).pipe(
+  Command.withDescription(
+    "Create a new S3-compatible object store (MinIO, DigitalOcean, etc.)",
+  ),
+);

package/src/commands/cluster/object-store/create.ts

@@ -0,0 +1,20 @@
+import { Command } from "@effect/cli";
+import { Effect } from "effect";
+import { createObjectStoreAwsCommand } from "./create-aws.js";
+import { createObjectStoreAzureCommand } from "./create-azure.js";
+import { createObjectStoreGoogleCommand } from "./create-google.js";
+import { createObjectStoreS3Command } from "./create-s3.js";
+
+export const createObjectStoreCommand = Command.make(
+  "create-object-store",
+  {},
+  () => Effect.void,
+).pipe(
+  Command.withDescription("Create a new object store"),
+  Command.withSubcommands([
+    createObjectStoreAwsCommand,
+    createObjectStoreAzureCommand,
+    createObjectStoreGoogleCommand,
+    createObjectStoreS3Command,
+  ]),
+);

package/src/commands/cluster/object-store/delete.ts

@@ -0,0 +1,58 @@
+import { WingsClusterMetadata } from "@airfoil/wings";
+import * as p from "@clack/prompts";
+import { Command, Options } from "@effect/cli";
+import { Effect } from "effect";
+import { makeClusterMetadataLayer } from "../../../utils/client.js";
+import { handleCliError } from "../../../utils/effect.js";
+import { forceOption, hostOption, portOption } from "../../../utils/options.js";
+
+const nameOption = Options.text("name").pipe(
+  Options.withDescription(
+    "Object store name in format: tenants/{tenant}/object-stores/{object-store}",
+  ),
+);
+
+export const deleteObjectStoreCommand = Command.make(
+  "delete-object-store",
+  {
+    name: nameOption,
+    force: forceOption,
+    host: hostOption,
+    port: portOption,
+  },
+  ({ name, force, host, port }) =>
+    Effect.gen(function* () {
+      p.intro("🗑️  Delete Object Store");
+
+      if (!force) {
+        const confirm = yield* Effect.tryPromise({
+          try: () =>
+            p.confirm({
+              message: `Are you sure you want to delete object store ${name}?`,
+              initialValue: false,
+            }),
+          catch: () => new Error("Failed to confirm deletion"),
+        });
+
+        if (p.isCancel(confirm) || !confirm) {
+          p.cancel("Deletion cancelled");
+          process.exit(0);
+        }
+      }
+
+      const layer = makeClusterMetadataLayer(host, port);
+
+      const s = p.spinner();
+      s.start("Deleting object store...");
+
+      yield* WingsClusterMetadata.deleteObjectStore({ name }).pipe(
+        Effect.provide(layer),
+        Effect.tapError(() =>
+          Effect.sync(() => s.stop("Failed to delete object store")),
+        ),
+      );
+
+      s.stop("Object store deleted successfully");
+      p.outro("✓ Done");
+    }).pipe(Effect.catchAll(handleCliError("Failed to delete object store"))),
+).pipe(Command.withDescription("Delete an object store from the cluster"));

package/src/commands/cluster/object-store/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(
+    "Object store name in format: tenants/{tenant}/object-stores/{object-store}",
+  ),
+);
+
+export const getObjectStoreCommand = Command.make(
+  "get-object-store",
+  {
+    name: nameOption,
+    host: hostOption,
+    port: portOption,
+  },
+  ({ name, host, port }) =>
+    Effect.gen(function* () {
+      const layer = makeClusterMetadataLayer(host, port);
+
+      const s = p.spinner();
+      s.start("Fetching object store...");
+
+      const objectStore = yield* WingsClusterMetadata.getObjectStore({
+        name,
+      }).pipe(
+        Effect.provide(layer),
+        Effect.tapError(() =>
+          Effect.sync(() => s.stop("Failed to get object store")),
+        ),
+      );
+
+      s.stop("Object store retrieved");
+
+      yield* Effect.sync(() => {
+        printTable([
+          {
+            name: objectStore.name,
+            type: objectStore.objectStoreConfig._tag || "-",
+          },
+        ]);
+        p.outro("✓ Done");
+      });
+    }).pipe(Effect.catchAll(handleCliError("Failed to get object store"))),
+).pipe(Command.withDescription("Get details of a specific object store"));